kitecli 0.2.5__tar.gz → 0.2.9__tar.gz

{kitecli-0.2.5 → kitecli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.2.5
+Version: 0.2.9
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT

{kitecli-0.2.5 → kitecli-0.2.9}/cli/api_client.py

@@ -141,11 +141,13 @@ class KCLIClient:
                 is_valid = False
                 if mgr.is_authenticated(account_key):
                     try:
-                        mgr._clients[account_key].limits()
+                        resp = mgr._clients[account_key].limits()
+                        from cli.kotak_manager import _check_neo_error
+                        _check_neo_error(resp)
                         is_valid = True
                     except Exception as exc:
                         msg = str(exc).lower()
-                        is_auth_error = any(x in msg for x in ["100008", "unauthorized", "invalid token", "session expired", "session has been closed", "session closed"])
+                        is_auth_error = any(x in msg for x in ["100008", "100022", "1037", "unauthorized", "invalid token", "invalid session", "session expired", "session has been closed", "session closed"])
                         if is_auth_error:
                             logger.info("Kotak validation failed (expired/invalid) for %s: %s", name, exc)
                             mgr._authenticated[account_key] = False

{kitecli-0.2.5 → kitecli-0.2.9}/cli/kite_manager.py

@@ -1039,22 +1039,36 @@ class KiteAccountManager(BaseBrokerManager):
         return {}
 
     def get_market_indices(self) -> dict[str, Any]:
-        # 1. Try Kite first
+        # 1. Try Kite ohlc first for last_price and yesterday's close
         for api_key in self.get_all_api_keys():
             if self.is_authenticated(api_key):
                 kite = self._clients.get(api_key)
                 if kite:
                     try:
-                        data = kite.ltp(["NSE:NIFTY 50", "BSE:SENSEX", "NSE:INDIA VIX"])
-                        nifty = data.get("NSE:NIFTY 50", {}).get("last_price")
-                        sensex = data.get("BSE:SENSEX", {}).get("last_price")
-                        vix = data.get("NSE:INDIA VIX", {}).get("last_price")
-                        if nifty or sensex or vix:
+                        data = kite.ohlc(["NSE:NIFTY 50", "BSE:SENSEX", "NSE:INDIA VIX"])
+                        
+                        def parse_item(item_data):
+                            if not isinstance(item_data, dict):
+                                return None, None
+                            last = item_data.get("last_price")
+                            ohlc = item_data.get("ohlc", {})
+                            close = ohlc.get("close") if isinstance(ohlc, dict) else None
+                            change = (last - close) if (last is not None and close is not None) else None
+                            return last, change
+
+                        nifty_last, nifty_change = parse_item(data.get("NSE:NIFTY 50"))
+                        sensex_last, sensex_change = parse_item(data.get("BSE:SENSEX"))
+                        vix_last, vix_change = parse_item(data.get("NSE:INDIA VIX"))
+
+                        if nifty_last or sensex_last or vix_last:
                             return {
                                 "status": "success",
-                                "nifty": nifty,
-                                "sensex": sensex,
-                                "vix": vix,
+                                "nifty": nifty_last,
+                                "nifty_change": nifty_change,
+                                "sensex": sensex_last,
+                                "sensex_change": sensex_change,
+                                "vix": vix_last,
+                                "vix_change": vix_change,
                             }
                     except Exception as exc:
                         logger.warning("Kite indices fetch failed for api_key=%s…: %s", api_key[:8], exc)

{kitecli-0.2.5 → kitecli-0.2.9}/cli/kotak_manager.py

@@ -137,7 +137,9 @@ class KotakAccountManager(BaseBrokerManager):
 
     def init_account(self, account_key: str, **credentials) -> str:
         """ABC entry point — delegates to init_account_kotak."""
-        return self.init_account_kotak(consumer_key=account_key, **credentials)
+        creds = dict(credentials)
+        creds.pop("consumer_key", None)
+        return self.init_account_kotak(consumer_key=account_key, **creds)
 
     def init_account_kotak(
         self,
@@ -226,70 +228,82 @@ class KotakAccountManager(BaseBrokerManager):
             if 'Content-Type' not in headers:
                 headers['Content-Type'] = 'application/json'
 
-            u = url
-            if query_params:
-                u_with_params = u
-                if '?' not in u:
-                    u_with_params += '?' + _urlencode(query_params)
+            def _do_req(h, max_proxy_retries: int = 2):
+                if query_params and isinstance(query_params, dict):
+                    base_u = url.split('?')[0]
+                    u_curr = base_u + '?' + _urlencode(query_params)
                 else:
-                    pass
-            else:
-                u_with_params = u
+                    u_curr = url
 
-            def _do_req(h):
                 req_kwargs = {}
                 if _proxies:
-                    # Kotak Neo static IP whitelisting is only enforced on order APIs
-                    url_lower = u_with_params.lower()
-                    if "/order/" in url_lower and any(x in url_lower for x in ["/place", "/modify", "/cancel"]):
+                    url_lower = u_curr.lower()
+                    is_order_api = "/order/" in url_lower and any(x in url_lower for x in ["/place", "/modify", "/cancel"])
+                    is_login_api = "/login/" in url_lower or "tradeapilogin" in url_lower or "tradeapivalidate" in url_lower
+                    if is_order_api or is_login_api:
                         req_kwargs["proxies"] = _proxies
 
-                logger.debug("Kotak REST [%s] requesting: %s", method, u_with_params)
+                logger.debug("Kotak REST [%s] requesting: %s", method, u_curr)
                 logger.debug("Kotak REST headers: %s", {k: v[:15] + '...' if len(str(v)) > 15 else v for k, v in h.items()})
 
-                if method in ['POST', 'PUT', 'PATCH', 'DELETE']:
-                    if _re.search('json', h['Content-Type'], _re.IGNORECASE):
-                        request_body = _json.dumps(body) if body is not None else None
-                        return _req.post(url=u_with_params, headers=h, data=request_body, **req_kwargs)
-                    elif _re.search('x-www-form-urlencoded', h['Content-Type'], _re.IGNORECASE):
-                        request_body = {"jData": _json.dumps(body)} if body is not None else {}
-                        return _req.post(url=u_with_params, headers=h, data=request_body, **req_kwargs)
-                elif method == 'GET':
-                    return _req.get(url=u_with_params, headers=h, **req_kwargs)
-                return _orig_request(method, url, query_params=query_params, headers=h, body=body)
+                try:
+                    if method in ['POST', 'PUT', 'PATCH', 'DELETE']:
+                        if _re.search('json', h.get('Content-Type', ''), _re.IGNORECASE):
+                            request_body = _json.dumps(body) if body is not None else None
+                            return _req.post(url=u_curr, headers=h, data=request_body, **req_kwargs)
+                        elif _re.search('x-www-form-urlencoded', h.get('Content-Type', ''), _re.IGNORECASE):
+                            request_body = {"jData": _json.dumps(body)} if body is not None else {}
+                            return _req.post(url=u_curr, headers=h, data=request_body, **req_kwargs)
+                    elif method == 'GET':
+                        return _req.get(url=u_curr, headers=h, **req_kwargs)
+                    return _orig_request(method, url, query_params=query_params, headers=h, body=body)
+                except Exception as req_exc:
+                    exc_str = str(req_exc).lower()
+                    if max_proxy_retries > 0 and _proxies and ("proxy" in exc_str or "502" in exc_str or "tunnel" in exc_str or "connect" in exc_str):
+                        import time
+                        logger.warning("Kotak static proxy transient error (%s). Retrying via proxy in 1s...", req_exc)
+                        time.sleep(1.0)
+                        return _do_req(h, max_proxy_retries=max_proxy_retries - 1)
+                    raise
 
             resp = _do_req(headers)
-            logger.info("Kotak REST %s %s → status %s", method, u_with_params, resp.status_code)
+            logger.info("Kotak REST %s %s → status %s", method, url, resp.status_code)
             try:
                 logger.debug("Kotak REST response body: %s", resp.json())
             except Exception:
                 logger.debug("Kotak REST response body (raw): %s", resp.text[:200])
 
-            # Check for IP mismatch error (stCode 1037) or Session expired (stCode 100008)
+            # Check for IP mismatch error (stCode 1037), Session expired (stCode 100008, 100022), or HTTP 401
             try:
-                resp_json = resp.json()
+                resp_json = resp.json() if resp.text else {}
                 if isinstance(resp_json, dict):
                     st_code = resp_json.get("stCode")
                     err_msg = str(resp_json.get("errMsg", "")).lower()
                     if (
-                        st_code == 1037 or 
-                        st_code == 100008 or 
-                        "session ip" in err_msg or 
-                        "unauthorized" in err_msg
+                        resp.status_code == 401 or
+                        st_code in (1037, 100008, 100022) or
+                        "session ip" in err_msg or
+                        "unauthorized" in err_msg or
+                        "invalid session" in err_msg or
+                        "invalid token" in err_msg
                     ):
                         logger.info("Kotak session invalid (stCode=%s, msg='%s') for account '%s'. Triggering auto-login...", st_code, resp_json.get("errMsg"), name)
                         if self.auto_login(consumer_key):
                             # Update headers with new credentials
+                            new_sid = client.configuration.serverId or client.configuration.edit_sid
                             headers["Sid"] = client.configuration.edit_sid
                             headers["Auth"] = client.configuration.edit_token
+                            if new_sid:
+                                url = _re.sub(r'([?&]sId=)[^&]*', r'\g<1>' + str(new_sid), url)
+                                url = _re.sub(r'([?&]sid=)[^&]*', r'\g<1>' + str(new_sid), url)
                             if isinstance(query_params, dict):
                                 if "sId" in query_params:
-                                    query_params["sId"] = client.configuration.serverId
+                                    query_params["sId"] = new_sid
                                 if "sid" in query_params:
-                                    query_params["sid"] = client.configuration.edit_sid
+                                    query_params["sid"] = new_sid
                             logger.info("Retrying request after successful auto-login...")
                             resp = _do_req(headers)
-                            logger.info("Kotak REST retry %s %s → status %s", method, u_with_params, resp.status_code)
+                            logger.info("Kotak REST retry %s %s → status %s", method, url, resp.status_code)
                             try:
                                 logger.debug("Kotak REST retry response body: %s", resp.json())
                             except Exception:
@@ -624,6 +638,18 @@ class KotakAccountManager(BaseBrokerManager):
             except ValueError:
                 pending_quantity = 0
 
+            fld_qty_str = str(ord.get("fldQty", ord.get("filled_quantity", "0")))
+            try:
+                filled_quantity = int(fld_qty_str)
+            except ValueError:
+                filled_quantity = 0
+
+            avg_prc_str = str(ord.get("avgPrc", ord.get("average_price", "0")))
+            try:
+                average_price = float(avg_prc_str)
+            except ValueError:
+                average_price = 0.0
+
             price_str = str(ord.get("prc", ord.get("price", "0")))
             try:
                 price = float(price_str)
@@ -635,8 +661,10 @@ class KotakAccountManager(BaseBrokerManager):
                 "tradingsymbol": ord.get("trdSym", ord.get("tradingsymbol", "")),
                 "transaction_type": str(ord.get("trnsTp", ord.get("transaction_type", ""))).upper(),
                 "quantity": quantity,
+                "filled_quantity": filled_quantity,
                 "pending_quantity": pending_quantity,
                 "price": price,
+                "average_price": average_price,
                 "order_type": str(ord.get("prcTp", ord.get("order_type", "MARKET"))).upper(),
                 "status": status,
                 "product": str(ord.get("prod", ord.get("product", "NRML"))).upper(),
@@ -655,6 +683,7 @@ class KotakAccountManager(BaseBrokerManager):
 
         try:
             resp = client.limits()
+            _check_neo_error(resp)
             if isinstance(resp, dict):
                 data = resp.get("data", resp)
                 net = data.get("Net", data.get("net"))

{kitecli-0.2.5 → kitecli-0.2.9}/cli/live_session.py

@@ -312,6 +312,7 @@ class KCLILiveSession:
         #   NSE:NIFTY 50 -> 256265, BSE:SENSEX -> 265, NSE:INDIA VIX -> 264969
         self.index_tokens = {256265: "nifty", 265: "sensex", 264969: "vix"}
         self.index_values = {"nifty": None, "sensex": None, "vix": None}
+        self.index_close_prices = {}
 
         # Designated primary streaming account. Index and option-chain ticks are
         # subscribed only on this account's ticker (chosen in
@@ -1003,6 +1004,14 @@ class KCLILiveSession:
             " Advisor ",
             make_click_handler("advisor")
         ))
+        fragments.append(("", " "))
+
+        # Tab 5: Help
+        fragments.append((
+            "class:tab.active" if self.info_mode == "help" else "class:tab.inactive",
+            " Help ",
+            make_click_handler("help")
+        ))
         
         return fragments
 
@@ -1162,6 +1171,12 @@ class KCLILiveSession:
     async def _initial_fetch_and_connect(self) -> None:
         """Initial fetch of data and connect all WebSockets."""
         self.log_message("Initializing connections and fetching data...")
+
+        # Ensure accounts are validated & auto-logged in
+        try:
+            await self._run_api_call(self.client.init_accounts, self.accounts)
+        except Exception as e:
+            self.log_message(f"[#ff8700]Account init warning:[/#] {e}")
         
         # Fire off REST data fetch in the background so it doesn't block WebSockets
         if hasattr(self, "app") and self.app and self.app.loop:
@@ -1188,7 +1203,7 @@ class KCLILiveSession:
             )
 
         # Connect WebSockets for accounts that support it (Zerodha and Kotak).
-        for idx, acct in enumerate(self.accounts):
+        for acct in self.accounts:
             api_key = acct.get("api_key")
             broker = acct.get("broker", "zerodha").lower()
             access_token = self.client.get_access_token(api_key)
@@ -1201,9 +1216,6 @@ class KCLILiveSession:
                 )
                 continue
 
-            if idx > 0:
-                await asyncio.sleep(0.2)
-
             if api_key and (access_token or broker == "kotak"):
                 try:
                     if broker == "kotak":
@@ -1318,7 +1330,9 @@ class KCLILiveSession:
                 code == 403
                 or "403" in reason_str
                 or "auth_failed" in reason_str
-                or "token" in reason_str
+                or "invalid token" in reason_str
+                or "token expired" in reason_str
+                or "unauthorized" in reason_str
             )
             if is_auth_failure:
                 self.log_message(
@@ -1367,9 +1381,22 @@ class KCLILiveSession:
             if not token or ltp is None:
                 continue
 
-            # Market index tick → update the header values.
+            # Market index tick → update the header values & streaming change.
             if token in self.index_tokens:
-                self.index_values[self.index_tokens[token]] = ltp
+                key = self.index_tokens[token]
+                self.index_values[key] = ltp
+
+                # Extract close from tick OHLC if available, or use cached REST close price
+                tick_close = None
+                if isinstance(tick.get("ohlc"), dict):
+                    tick_close = tick["ohlc"].get("close")
+                if tick_close:
+                    self.index_close_prices[key] = tick_close
+
+                close_val = self.index_close_prices.get(key)
+                if close_val is not None:
+                    self.index_values[f"{key}_change"] = ltp - close_val
+
                 indices_updated = True
                 continue
 
@@ -1447,18 +1474,82 @@ class KCLILiveSession:
             self.app.invalidate()
 
     def _render_indices_html(self) -> HTML:
-        """Build the formatted market-index header from the current values."""
-        def fmt(v):
-            return f"{v:,.2f}" if v else "N/A"
-
-        nifty_str = fmt(self.index_values.get("nifty"))
-        sensex_str = fmt(self.index_values.get("sensex"))
-        vix_str = fmt(self.index_values.get("vix"))
-        return HTML(
-            f"  <ansicyan><b>NIFTY 50:</b></ansicyan> <style fg='#ffffff'>{nifty_str}</style>   "
-            f"│   <ansiyellow><b>SENSEX:</b></ansiyellow> <style fg='#ffffff'>{sensex_str}</style>   "
-            f"│   <ansired><b>INDIA VIX:</b></ansired> <style fg='#ffffff'>{vix_str}</style>"
-        )
+        """Build formatted market-index header tailored to the Right Pane width."""
+        total_cols = 100
+        if hasattr(self, "app") and self.app and hasattr(self.app, "output") and self.app.output:
+            try:
+                cols = self.app.output.get_size().columns
+                if isinstance(cols, int):
+                    total_cols = cols
+            except Exception:
+                pass
+
+        # The indices bar is rendered inside the Right Pane, so compute right pane width
+        lw = getattr(self, "left_pane_weight", 50)
+        rw = getattr(self, "right_pane_weight", 50)
+        pane_cols = int(total_cols * (rw / max(1, lw + rw)))
+
+        def fmt_item(val, chg, is_vix: bool = False, compact: bool = False):
+            if val is None:
+                return "<style fg='#ffffff'>N/A</style>"
+            val_str = f"{val:,.2f}"
+            if chg is None:
+                return f"<style fg='#ffffff'>{val_str}</style>"
+
+            # For VIX: negative change (volatility drop) is green, positive (volatility spike) is red
+            # For NIFTY/SENSEX: positive is green, negative is red
+            if is_vix:
+                color = "#00ff00" if chg <= 0 else "#ff5f5f"
+            else:
+                color = "#00ff00" if chg >= 0 else "#ff5f5f"
+
+            sign = "+" if chg >= 0 else ""
+            if compact:
+                # In tight right-pane spaces, round large changes to integers e.g. (+80) instead of (+80.50)
+                chg_str = f"{sign}{int(round(chg)):,d}" if not is_vix else f"{sign}{chg:.2f}"
+            else:
+                chg_str = f"{sign}{chg:,.2f}"
+            return f"<style fg='{color}'>{val_str} ({chg_str})</style>"
+
+        if pane_cols >= 75:
+            # Full width: NIFTY 50: 24,234.85 (-99.80) │ SENSEX: 77,708.24 (-441.41) │ IV: 13.45 (+0.25)
+            nifty_html = fmt_item(self.index_values.get("nifty"), self.index_values.get("nifty_change"))
+            sensex_html = fmt_item(self.index_values.get("sensex"), self.index_values.get("sensex_change"))
+            vix_html = fmt_item(self.index_values.get("vix"), self.index_values.get("vix_change"), is_vix=True)
+            return HTML(
+                f" <ansicyan><b>NIFTY 50:</b></ansicyan> {nifty_html} "
+                f"│ <ansiyellow><b>SENSEX:</b></ansiyellow> {sensex_html} "
+                f"│ <ansired><b>IV:</b></ansired> {vix_html}"
+            )
+        elif pane_cols >= 55:
+            # Medium width: NIFTY: 24,234.85 (-100) │ SENSEX: 77,708.24 (-441) │ IV: 13.45 (+0.25)
+            nifty_html = fmt_item(self.index_values.get("nifty"), self.index_values.get("nifty_change"), compact=True)
+            sensex_html = fmt_item(self.index_values.get("sensex"), self.index_values.get("sensex_change"), compact=True)
+            vix_html = fmt_item(self.index_values.get("vix"), self.index_values.get("vix_change"), is_vix=True, compact=True)
+            return HTML(
+                f"<ansicyan><b>NIFTY:</b></ansicyan> {nifty_html} "
+                f"│ <ansiyellow><b>SENSEX:</b></ansiyellow> {sensex_html} "
+                f"│ <ansired><b>IV:</b></ansired> {vix_html}"
+            )
+        else:
+            # Ultra compact for narrow right pane (< 55 cols): N: 24,234.85 │ S: 77,708.24 │ IV: 13.45
+            def fmt_val_only(val, chg, is_vix=False):
+                if val is None:
+                    return "<style fg='#ffffff'>N/A</style>"
+                val_str = f"{val:,.2f}"
+                if chg is None:
+                    return f"<style fg='#ffffff'>{val_str}</style>"
+                color = ("#00ff00" if chg <= 0 else "#ff5f5f") if is_vix else ("#00ff00" if chg >= 0 else "#ff5f5f")
+                return f"<style fg='{color}'>{val_str}</style>"
+
+            nifty_html = fmt_val_only(self.index_values.get("nifty"), self.index_values.get("nifty_change"))
+            sensex_html = fmt_val_only(self.index_values.get("sensex"), self.index_values.get("sensex_change"))
+            vix_html = fmt_val_only(self.index_values.get("vix"), self.index_values.get("vix_change"), is_vix=True)
+            return HTML(
+                f"<ansicyan><b>N:</b></ansicyan> {nifty_html} "
+                f"│ <ansiyellow><b>S:</b></ansiyellow> {sensex_html} "
+                f"│ <ansired><b>IV:</b></ansired> {vix_html}"
+            )
 
     def _get_active_ticker(self):
         """Get the primary ticker if it is connected, else fallback to any connected ticker."""
@@ -1719,9 +1810,20 @@ class KCLILiveSession:
                         if self._ws_should_log("rest_err:indices", min_interval=30.0):
                             self.log_message(f"[#ff8700]Indices fetch failed:[/#] {self._clean_error(str(indices_resp))}")
                     elif isinstance(indices_resp, dict) and indices_resp.get("status") == "success":
-                        self.index_values["nifty"]  = indices_resp.get("nifty")
-                        self.index_values["sensex"] = indices_resp.get("sensex")
-                        self.index_values["vix"]    = indices_resp.get("vix")
+                        self.index_values["nifty"]         = indices_resp.get("nifty")
+                        self.index_values["nifty_change"]  = indices_resp.get("nifty_change")
+                        self.index_values["sensex"]        = indices_resp.get("sensex")
+                        self.index_values["sensex_change"] = indices_resp.get("sensex_change")
+                        self.index_values["vix"]           = indices_resp.get("vix")
+                        self.index_values["vix_change"]    = indices_resp.get("vix_change")
+
+                        # Cache close prices (last - change) so live WebSocket ticks can dynamically recalculate change
+                        for key in ["nifty", "sensex", "vix"]:
+                            last_val = self.index_values.get(key)
+                            chg_val = self.index_values.get(f"{key}_change")
+                            if last_val is not None and chg_val is not None:
+                                self.index_close_prices[key] = last_val - chg_val
+
                         self.market_indices_control.text = self._render_indices_html()
                     elif isinstance(indices_resp, dict):
                         errors_this_cycle += 1
@@ -2320,6 +2422,44 @@ class KCLILiveSession:
                 )
             return
 
+        # Direct commands to switch info pane mode
+        cmd_norm = cmd.strip().lower()
+        if cmd_norm in ("pending", "p", "1", "/1", "/pending"):
+            self.info_mode = "orders_pending"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Pending Orders[/bold].")
+            return
+        elif cmd_norm in ("executed", "e", "ex", "2", "/2", "/executed"):
+            self.info_mode = "orders_executed"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Executed Orders[/bold].")
+            return
+        elif cmd_norm in ("oc", "optionchain", "chain", "3", "/3", "/oc"):
+            self.info_mode = "oc"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Option Chain[/bold].")
+            return
+        elif cmd_norm in ("advisor", "adv", "ai", "4", "/4", "/advisor"):
+            self.info_mode = "advisor"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]AI Advisor[/bold].")
+            return
+        elif cmd_norm in ("help", "h", "5", "/5", "/help"):
+            self.info_mode = "help"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Help & Shortcuts[/bold].")
+            return
+
         # Attempt parsing via the unified parser
         try:
             parsed_cmds = parse_command_line(cmd)
@@ -3826,6 +3966,59 @@ class KCLILiveSession:
             lines.append("No pending orders across all accounts.")
         return "\n".join(lines)
 
+    def _build_help_text(self) -> str:
+        """Return formatted keyboard shortcuts & command cheat sheet."""
+        return """=== KiteCLI Keyboard & Command Cheat Sheet ===
+
+1. TAB SWITCHING (RIGHT PANE)
+   Type at prompt:
+     p or pending or 1  -> Switch to Pending Orders tab
+     e or executed or 2 -> Switch to Executed Orders tab
+     oc or chain or 3   -> Switch to Option Chain tab
+     adv or advisor or 4-> Switch to AI Advisor tab
+     h or help or 5     -> Switch to this Help tab
+
+   Universal Hotkeys:
+     Ctrl + P           -> Pending Orders
+     Ctrl + E           -> Executed Orders
+     Ctrl + O           -> Option Chain
+     Ctrl + G           -> AI Advisor
+     F5 / Esc+5         -> Help
+
+   Function Keys / Alt:
+     F1 / F2 / F3 / F4 / F5
+     Option+1 / 2 / 3 / 4 / 5 (or Esc then 1..5)
+     Mouse Click: Click directly on any tab title in header bar
+
+2. ORDER PLACEMENT & TRADING COMMANDS
+   Buy / Sell Orders:
+     b <symbol> <qty> [price]     -> Buy limit/market (e.g. b NIFTY26JUL22500PE 100 1.40)
+     s <symbol> <qty> [price]     -> Sell limit/market (e.g. s BANKNIFTY26JUL50000CE 15@2.50)
+     b 1 100                       -> Buy 100 qty of active position #1
+     s 2                           -> Sell/exit all qty of active position #2
+
+   Exiting Positions:
+     exit <symbol|id> [price]     -> Exit position by symbol or table ID (e.g. exit 1, exit 2 1.50)
+     exit all [price]              -> Exit all active positions (e.g. exit all)
+
+   Modifying & Cancelling:
+     modify <order_id> [qty] [price] -> Modify open order
+     cancel <order_id>               -> Cancel pending order
+     cancel all                      -> Cancel all open/pending orders
+
+3. SELECTION & SELECTION CLEARING
+   Selection:
+     Click on symbol/account row   -> Target specific position/account
+     Esc                             -> Clear active selection / reset account filter
+
+4. GLOBAL NAVIGATION & CONTROL
+   Tab           -> Cycle focus (Input box -> Positions -> Right Pane)
+   Ctrl + R      -> Search command history
+   Ctrl + Left   -> Narrow left pane split width
+   Ctrl + Right  -> Widen left pane split width
+   Ctrl + C      -> Exit KiteCLI
+"""
+
     def _update_info_buffer(self, reset_scroll: bool = True) -> None:
         """Push current info_mode text into the info_buffer.
 
@@ -3846,6 +4039,8 @@ class KCLILiveSession:
             except Exception as exc:
                 self._last_advisor_text = f"=== Tuesday Expiry Advisor ===\n\nFailed to plan: {exc}"
             text = self._last_advisor_text
+        elif self.info_mode == "help":
+            text = self._build_help_text()
         else:
             text = self._last_oc_text
         if reset_scroll:
@@ -4217,8 +4412,10 @@ class KCLILiveSession:
                 nxt = self.input_field.control
             event.app.layout.focus(nxt)
 
-        # Ctrl+1/2/3/4 & F1-F4 — switch info pane content
+        # Ctrl+1/2/3/4, Ctrl+P/E/O/G, Alt/Esc+1/2/3/4, F1-F4 — switch info pane content
         @kb.add("c-1")
+        @kb.add("c-p")
+        @kb.add("escape", "1")
         @kb.add("f1")
         def _c1(event):
             self.info_mode = "orders_pending"
@@ -4226,6 +4423,8 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-2")
+        @kb.add("c-e")
+        @kb.add("escape", "2")
         @kb.add("f2")
         def _c2(event):
             self.info_mode = "orders_executed"
@@ -4233,6 +4432,8 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-3")
+        @kb.add("c-o")
+        @kb.add("escape", "3")
         @kb.add("f3")
         def _c3(event):
             self.info_mode = "oc"
@@ -4240,12 +4441,22 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-4")
+        @kb.add("c-g")
+        @kb.add("escape", "4")
         @kb.add("f4")
         def _c4(event):
             self.info_mode = "advisor"
             self._update_info_buffer()
             event.app.invalidate()
 
+        @kb.add("c-5")
+        @kb.add("escape", "5")
+        @kb.add("f5")
+        def _c5(event):
+            self.info_mode = "help"
+            self._update_info_buffer()
+            event.app.invalidate()
+
         # Ctrl+Left/Right — adjust left/right pane split
         @kb.add("c-left")
         def _narrow_left(event):

{kitecli-0.2.5 → kitecli-0.2.9}/cli/main.py

@@ -206,6 +206,7 @@ def live() -> None:
         display_error("No accounts configured. Edit your config file to add accounts.")
         raise typer.Exit(code=1)
     client = _build_client(config)
+    client.init_accounts(accounts)
 
     # Launch interactive session
     session = KCLILiveSession(client, accounts)

{kitecli-0.2.5 → kitecli-0.2.9}/kitecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.2.5
+Version: 0.2.9
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT

{kitecli-0.2.5 → kitecli-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kitecli"
-version = "0.2.5"
+version = "0.2.9"
 description = "KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)"
 readme = "README.md"
 requires-python = ">=3.10"