msapling-cli 0.1.3__tar.gz → 0.1.4__tar.gz

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msapling-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: MSapling CLI - Multi-chat AI development environment in your terminal
 Author: MSapling Team
 License-Expression: MIT
@@ -31,9 +31,12 @@ Provides-Extra: keyring
 Requires-Dist: keyring>=24.0; extra == "keyring"
 Provides-Extra: tui
 Requires-Dist: textual>=0.40.0; extra == "tui"
+Provides-Extra: pdf
+Requires-Dist: pdfplumber>=0.10.0; extra == "pdf"
 Provides-Extra: all
 Requires-Dist: keyring>=24.0; extra == "all"
 Requires-Dist: textual>=0.40.0; extra == "all"
+Requires-Dist: pdfplumber>=0.10.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: build>=1.2.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/__init__.py

@@ -1,2 +1,2 @@
 """MSapling CLI - Multi-chat AI development environment in your terminal."""
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/agent.py

@@ -56,7 +56,10 @@ _permission_mode: str = "ask"
 _permissions: Dict[str, bool] = {}
 
 # Read-only tools that never require approval in any mode
-_READ_ONLY_TOOLS = frozenset({"read_file", "glob_files", "grep_search", "web_search", "cost_check"})
+_READ_ONLY_TOOLS = frozenset({
+    "read_file", "glob_files", "grep_search", "web_search", "web_fetch",
+    "cost_check", "list_directory", "ask_user", "todo_list",
+})
 
 # Write tools blocked in readonly/plan mode
 _WRITE_TOOLS = frozenset({"write_file", "edit_file", "run_command"})
@@ -131,6 +134,31 @@ AGENT_TOOLS_SCHEMA = [
         "description": "Search the web for current information. Uses MSapling's backend search. Use when the user asks about recent events, documentation, or anything that might be outdated in your training data.",
         "parameters": {"query": "string (search query)"},
     },
+    {
+        "name": "web_fetch",
+        "description": "Fetch the content of a specific URL. Returns the page text (HTML stripped). Use for reading documentation, API references, or specific web pages.",
+        "parameters": {"url": "string (full URL to fetch)"},
+    },
+    {
+        "name": "list_directory",
+        "description": "List files and directories at a path with sizes and types. More detailed than glob_files.",
+        "parameters": {"path": "string (relative directory path, default '.')"},
+    },
+    {
+        "name": "ask_user",
+        "description": "Ask the user a clarifying question when you need more information to proceed. Use sparingly — only when truly ambiguous.",
+        "parameters": {"question": "string (the question to ask)"},
+    },
+    {
+        "name": "todo_list",
+        "description": "Manage a task checklist for the current session. Use to plan multi-step work and track progress.",
+        "parameters": {"action": "string ('add', 'done', 'list', 'clear')", "item": "string (task description, for 'add' and 'done')"},
+    },
+    {
+        "name": "search_replace_all",
+        "description": "Replace ALL occurrences of a string in a file (not just the first). Use when renaming a variable or updating all imports.",
+        "parameters": {"path": "string (relative file path)", "old_string": "string (text to find)", "new_string": "string (replacement)"},
+    },
     {
         "name": "cost_check",
         "description": "Check the user's remaining fuel credits and session cost before expensive operations. Use this before large file writes or multi-step tasks.",
@@ -157,17 +185,22 @@ To use a tool, respond with a JSON block in this format:
 ```
 
 Available tools:
-- read_file: Read a file. Args: path, offset (optional), limit (optional)
+- read_file: Read a file (supports text, PDF, notebooks). Args: path, offset (optional), limit (optional)
 - write_file: Create/overwrite a file. Args: path, content
-- edit_file: Replace a specific string in a file. Args: path, old_string, new_string
+- edit_file: Replace first occurrence of a string. Args: path, old_string, new_string
+- search_replace_all: Replace ALL occurrences in a file. Args: path, old_string, new_string
 - run_command: Execute a shell command. Args: command
+- list_directory: List files with sizes and types. Args: path (default ".")
 - glob_files: Find files by pattern. Args: pattern
 - grep_search: Search file contents. Args: pattern, path (optional)
 - web_search: Search the web via MSapling backend. Args: query
-- cost_check: Check remaining fuel credits and session cost. No args.
-- model_switch: Switch to a different model mid-task. Args: model (e.g. "google/gemini-2.0-flash-001")
+- web_fetch: Fetch content of a specific URL. Args: url
+- ask_user: Ask the user a clarifying question. Args: question
+- todo_list: Manage task checklist. Args: action (add/done/list/clear), item
+- cost_check: Check remaining fuel credits. No args.
+- model_switch: Switch model mid-task. Args: model
 
-Cost tips: Use cost_check before expensive multi-step tasks. Use model_switch to use cheaper models for boilerplate.
+Tips: Use cost_check before expensive tasks. Use model_switch for cheaper models on grunt work. Use search_replace_all for renaming variables across a file.
 
 You can use multiple tools in one response. After tool results, continue reasoning.
 When you're done (no more tools needed), just respond with your final message.
@@ -356,17 +389,103 @@ def _web_search(query: str) -> str:
         return f"Web search error: {e}"
 
 
+# ─── Command Sandbox ─────────────────────────────────────────────────
+# Block dangerous command patterns. Not OS-level but catches common mistakes.
+
+_BLOCKED_COMMAND_PATTERNS = [
+    r"\brm\s+(-[rRf]+\s+)?/",           # rm -rf /
+    r"\brm\s+-[rRf]*\s+~",              # rm -rf ~
+    r"\brm\s+-[rRf]*\s+\.\.",           # rm -rf ..
+    r"\bsudo\b",                          # sudo anything
+    r"\bchmod\s+777\b",                  # chmod 777
+    r"\bchmod\s+-R\b",                   # chmod -R (recursive)
+    r"\bmkfs\b",                          # format filesystem
+    r"\bdd\s+if=",                       # dd disk write
+    r"\b:()\s*\{",                        # fork bomb
+    r"\bcurl\b.*\|\s*bash",             # curl | bash
+    r"\bwget\b.*\|\s*bash",            # wget | bash
+    r"\bcurl\b.*\|\s*sh",              # curl | sh
+    r"\bwget\b.*\|\s*sh",             # wget | sh
+    r">\s*/dev/sd",                      # write to disk device
+    r"\bshutdown\b",                     # shutdown
+    r"\breboot\b",                       # reboot
+    r"\bkill\s+-9\s+1\b",              # kill init
+    r"\biptables\b",                     # firewall rules
+    r"\bufw\b",                          # firewall
+]
+
+_sandbox_enabled: bool = True
+
+
+def _check_command_sandbox(command: str) -> Optional[str]:
+    """Check if a command is blocked by the sandbox. Returns error message or None."""
+    if not _sandbox_enabled:
+        return None
+    cmd_lower = command.lower().strip()
+    for pattern in _BLOCKED_COMMAND_PATTERNS:
+        if re.search(pattern, cmd_lower):
+            return f"Blocked by sandbox: '{command[:60]}' matches dangerous pattern. Use /sandbox off to disable."
+    return None
+
+
+def set_sandbox(enabled: bool) -> bool:
+    global _sandbox_enabled
+    _sandbox_enabled = enabled
+    return _sandbox_enabled
+
+
+# Strong references to background tasks so they don't get GC'd mid-flight.
+# See: https://docs.python.org/3/library/asyncio-task.html#creating-tasks
+_background_tasks: set = set()
+
+# Agent todo list (managed via todo_list tool)
+_agent_todos: List[Dict[str, Any]] = []
+
+
+def _mdrive_auto_push(project_root: str, rel_path: str, content: str, project_name: str = "", agent_id: str = "cli-agent"):
+    """Background push to MDrive after local file write. Best-effort, non-blocking."""
+    if not project_name:
+        return
+    try:
+        import asyncio as _aio
+        from .api import MSaplingClient
+
+        async def _push():
+            client = MSaplingClient()
+            try:
+                await client.mdrive_write(
+                    project_name, rel_path, content,
+                    agent_id=agent_id,
+                    change_summary="Auto-pushed by agent tool",
+                )
+            finally:
+                await client.close()
+
+        try:
+            loop = _aio.get_running_loop()
+            task = loop.create_task(_push())
+            # Hold strong reference until task completes
+            _background_tasks.add(task)
+            task.add_done_callback(_background_tasks.discard)
+        except RuntimeError:
+            _aio.run(_push())
+    except Exception:
+        pass  # Best-effort, never block the agent
+
+
 def _execute_tool(
     tool_name: str,
     args: Dict[str, Any],
     project_root: str,
     hooks_mgr: Any = None,
     model: str = "",
+    project_name: str = "",
 ) -> str:
     """Execute a single tool call locally. Returns result as string.
 
     When *hooks_mgr* is provided (a HooksManager), the function fires
     *on_file_write* hooks after a successful write_file or edit_file.
+    When *project_name* is set, auto-pushes written files to MDrive.
     """
 
     # --- Approval gate for mutating tools ---
@@ -382,7 +501,47 @@ def _execute_tool(
         if not fpath.is_file():
             return f"Error: file not found: {path}"
         try:
-            content = fpath.read_text(encoding="utf-8", errors="ignore")
+            ext = fpath.suffix.lower()
+
+            # PDF reading
+            if ext == ".pdf":
+                try:
+                    import pdfplumber
+                    text_parts = []
+                    with pdfplumber.open(fpath) as pdf:
+                        for i, page in enumerate(pdf.pages[:30]):
+                            page_text = page.extract_text() or ""
+                            if page_text.strip():
+                                text_parts.append(f"--- Page {i+1} ---\n{page_text}")
+                    content = "\n\n".join(text_parts) if text_parts else "(no extractable text)"
+                except ImportError:
+                    return "Error: PDF reading requires pdfplumber. Install: pip install pdfplumber"
+
+            # Jupyter notebook reading
+            elif ext == ".ipynb":
+                try:
+                    nb = json.loads(fpath.read_text(encoding="utf-8"))
+                    cells = nb.get("cells", [])
+                    parts = []
+                    for i, cell in enumerate(cells):
+                        cell_type = cell.get("cell_type", "code")
+                        source = "".join(cell.get("source", []))
+                        if cell_type == "markdown":
+                            parts.append(f"[Markdown cell {i+1}]\n{source}")
+                        else:
+                            parts.append(f"[Code cell {i+1}]\n```\n{source}\n```")
+                            outputs = cell.get("outputs", [])
+                            for out in outputs[:3]:
+                                if "text" in out:
+                                    parts.append("Output: " + "".join(out["text"])[:500])
+                    content = "\n\n".join(parts)
+                except Exception as e:
+                    return f"Error parsing notebook: {e}"
+
+            # Standard text file
+            else:
+                content = fpath.read_text(encoding="utf-8", errors="ignore")
+
             offset = int(args.get("offset", 0))
             limit = int(args.get("limit", 0))
             if offset or limit:
@@ -411,6 +570,8 @@ def _execute_tool(
                     project=project_root, model=model,
                     file=str(fpath), tool="write_file",
                 )
+            # Auto-push to MDrive (best-effort, non-blocking)
+            _mdrive_auto_push(project_root, path, content, project_name)
             return f"Wrote {len(content)} bytes to {path}"
         except Exception as e:
             return f"Error writing {path}: {e}"
@@ -431,7 +592,9 @@ def _execute_tool(
             # Backup before editing (like Claude Code's file-history)
             try:
                 from .storage import backup_file
-                backup_file(path, content, "agent")
+                import hashlib
+                session_key = hashlib.md5(project_root.encode()).hexdigest()[:12]
+                backup_file(path, content, session_key)
             except Exception:
                 pass
             new_content = content.replace(old_string, new_string, 1)
@@ -442,6 +605,8 @@ def _execute_tool(
                     project=project_root, model=model,
                     file=str(fpath), tool="edit_file",
                 )
+            # Auto-push to MDrive (best-effort, non-blocking)
+            _mdrive_auto_push(project_root, path, new_content, project_name)
             return f"Edited {path}: replaced {len(old_string)} chars with {len(new_string)} chars"
         except Exception as e:
             return f"Error editing {path}: {e}"
@@ -450,10 +615,14 @@ def _execute_tool(
         command = args.get("command", "")
         if not command:
             return "Error: no command provided"
+        # Sandbox check: block dangerous patterns
+        blocked = _check_command_sandbox(command)
+        if blocked:
+            return blocked
         try:
             result = subprocess.run(
                 command, shell=True, cwd=project_root,
-                capture_output=True, text=True, timeout=30,
+                capture_output=True, text=True, timeout=60,
             )
             output = ""
             if result.stdout:
@@ -463,7 +632,7 @@ def _execute_tool(
             output += f"\n(exit code: {result.returncode})"
             return output or "(no output)"
         except subprocess.TimeoutExpired:
-            return "Error: command timed out (30s limit)"
+            return "Error: command timed out (60s limit)"
         except Exception as e:
             return f"Error running command: {e}"
 
@@ -511,11 +680,138 @@ def _execute_tool(
             return "Error: no search query provided"
         return _web_search(query)
 
-    elif tool_name == "cost_check":
+    elif tool_name == "web_fetch":
+        url = args.get("url", "")
+        if not url:
+            return "Error: no URL provided"
         try:
+            # Try backend first, fall back to direct fetch
             from .config import get_settings, get_token
+            import httpx as _httpx
+            settings = get_settings()
+            api_url = settings.api_url.rstrip("/")
+            token = get_token()
+            cookies = {"msaplingauth": token} if token else {}
+            try:
+                resp = _httpx.post(
+                    f"{api_url}/api/tools/web-research",
+                    json={"url": url}, cookies=cookies, timeout=15.0,
+                )
+                if resp.status_code == 200:
+                    content = resp.json().get("content", resp.json().get("text", ""))
+                    if content and len(content) > 20:
+                        return content[:8000]
+            except Exception:
+                pass
+            # Direct fetch fallback
+            resp = _httpx.get(url, timeout=15.0, follow_redirects=True,
+                              headers={"User-Agent": "MSapling-CLI/0.2"})
+            text = resp.text
+            # Strip HTML tags for readability
+            text = re.sub(r"<script[^>]*>.*?</script>", "", text, flags=re.DOTALL)
+            text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL)
+            text = re.sub(r"<[^>]+>", " ", text)
+            text = re.sub(r"\s+", " ", text).strip()
+            return text[:8000] if text else "No content found"
+        except Exception as e:
+            return f"Error fetching URL: {e}"
+
+    elif tool_name == "list_directory":
+        dir_path = args.get("path", ".")
+        fpath = _safe_path(project_root, dir_path)
+        if not fpath:
+            return f"Error: path '{dir_path}' is outside project root"
+        if not fpath.is_dir():
+            return f"Error: not a directory: {dir_path}"
+        try:
+            skip = {".git", "node_modules", "__pycache__", "venv", ".venv", "dist", "build"}
+            entries = []
+            for item in sorted(fpath.iterdir()):
+                name = item.name
+                if name in skip:
+                    continue
+                if item.is_dir():
+                    entries.append(f"  {name}/")
+                else:
+                    size = item.stat().st_size
+                    size_str = f"{size / 1024:.1f}KB" if size > 1024 else f"{size}B"
+                    entries.append(f"  {name}  ({size_str})")
+                if len(entries) >= 80:
+                    entries.append(f"  ... (truncated)")
+                    break
+            return "\n".join(entries) if entries else "(empty directory)"
+        except Exception as e:
+            return f"Error: {e}"
+
+    elif tool_name == "ask_user":
+        question = args.get("question", "")
+        if not question:
+            return "Error: no question provided"
+        try:
+            console.print(f"\n[bold yellow]Agent asks:[/bold yellow] {question}")
+            answer = console.input("[bold green]Your answer:[/bold green] ")
+            return answer.strip() or "(no answer)"
+        except (KeyboardInterrupt, EOFError):
+            return "(user declined to answer)"
+
+    elif tool_name == "todo_list":
+        action = args.get("action", "list").lower()
+        item = args.get("item", "")
+        # Module-level todo storage
+        global _agent_todos
+        if action == "add" and item:
+            _agent_todos.append({"text": item, "done": False})
+            return f"Added: {item} ({len(_agent_todos)} total)"
+        elif action == "done" and item:
+            for t in _agent_todos:
+                if item.lower() in t["text"].lower() and not t["done"]:
+                    t["done"] = True
+                    return f"Completed: {t['text']}"
+            return f"Not found: {item}"
+        elif action == "clear":
+            _agent_todos.clear()
+            return "Todo list cleared"
+        else:
+            if not _agent_todos:
+                return "Todo list is empty"
+            lines = []
+            for i, t in enumerate(_agent_todos, 1):
+                mark = "x" if t["done"] else " "
+                lines.append(f"  [{mark}] {i}. {t['text']}")
+            return "\n".join(lines)
+
+    elif tool_name == "search_replace_all":
+        path = args.get("path", "")
+        old_string = args.get("old_string", "")
+        new_string = args.get("new_string", "")
+        fpath = _safe_path(project_root, path)
+        if not fpath:
+            return f"Error: path '{path}' is outside project root"
+        if not fpath.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            content = fpath.read_text(encoding="utf-8", errors="ignore")
+            count = content.count(old_string)
+            if count == 0:
+                return f"Error: string not found in {path}"
+            try:
+                from .storage import backup_file
+                import hashlib
+                session_key = hashlib.md5(project_root.encode()).hexdigest()[:12]
+                backup_file(path, content, session_key)
+            except Exception:
+                pass
+            new_content = content.replace(old_string, new_string)
+            fpath.write_text(new_content, encoding="utf-8")
+            _mdrive_auto_push(project_root, path, new_content, project_name)
+            return f"Replaced {count} occurrence(s) in {path}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    elif tool_name == "cost_check":
+        try:
             from .api import MSaplingClient
-            import asyncio as _asyncio
+            import concurrent.futures
 
             async def _check():
                 client = MSaplingClient()
@@ -531,7 +827,11 @@ def _execute_tool(
                 finally:
                     await client.close()
 
-            return _asyncio.get_event_loop().run_until_complete(_check())
+            # _execute_tool is sync but called from within a running event loop.
+            # Use a thread to avoid "event loop already running" RuntimeError.
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                result = pool.submit(asyncio.run, _check()).result(timeout=10)
+            return result
         except Exception as e:
             return f"Cost check error: {e}"
 
@@ -566,6 +866,8 @@ async def run_agent_loop(
     on_text: Any = None,
     on_usage: Any = None,
     hooks_mgr: Any = None,
+    project_name: str = "",
+    chat_id: str = "",
 ) -> str:
     """Run the agentic tool-use loop.
 
@@ -600,9 +902,10 @@ async def run_agent_loop(
         # Get LLM response
         parts = []
         async for chunk in client.stream_chat(
-            chat_id=str(uuid.uuid4())[:12],
+            chat_id=chat_id or str(uuid.uuid4())[:12],
             prompt=prompt if step == 0 else "",
             model=model,
+            project_name=project_name,
             history=messages[-30:],  # Keep recent context
         ):
             content = chunk.get("content", "")
@@ -648,6 +951,7 @@ async def run_agent_loop(
             result = _execute_tool(
                 tool_name, tool_args, project_root,
                 hooks_mgr=hooks_mgr, model=model,
+                project_name=project_name,
             )
 
             # on_after_tool hook

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/api.py

@@ -19,6 +19,14 @@ PAID_DEFAULT_CHAT_LIMIT = 10
 FREE_DEFAULT_CHAT_LIMIT = 5
 
 
+def _mdrive_scoped_path(project_id: str, file_path: str = "") -> str:
+    project = str(project_id or "").strip().strip("/")
+    rel = str(file_path or "").strip().strip("/")
+    if project and rel:
+        return f"{project}/{rel}"
+    return project or rel or "."
+
+
 def _is_paid_user(user: Optional[Dict[str, Any]]) -> bool:
     tier = str((user or {}).get("tier", "free")).lower()
     return bool((user or {}).get("is_pro", False)) or tier in ("lifetime", "monthly", "pro", "enterprise")
@@ -303,7 +311,7 @@ class MSaplingClient:
     async def list_project_chats(self, project_name: str) -> List[Dict[str, Any]]:
         """Get chats for a specific project."""
         client = await self._get_client()
-        resp = await _retry_request(lambda: client.get("/api/projects", params={
+        resp = await _retry_request(lambda: client.get("/api/projects/", params={
             "limit": 100,
         }))
         resp.raise_for_status()
@@ -416,14 +424,16 @@ class MSaplingClient:
 
     async def list_files(self, project_id: str, path: str = "/") -> list:
         client = await self._get_client()
-        resp = await _retry_request(lambda: client.get("/api/mdrive/list", params={"project_id": project_id, "path": path}))
+        scoped_path = _mdrive_scoped_path(project_id, "" if path in ("", "/", ".") else path)
+        resp = await _retry_request(lambda: client.get("/api/mdrive/list", params={"path": scoped_path}))
         resp.raise_for_status()
         data = resp.json()
         return data if isinstance(data, list) else data.get("files", [])
 
     async def mdrive_read(self, project_id: str, file_path: str) -> str:
         client = await self._get_client()
-        resp = await _retry_request(lambda: client.post("/api/mdrive/read", json={"project_id": project_id, "file_path": file_path}))
+        payload = {"path": _mdrive_scoped_path(project_id, file_path)}
+        resp = await _retry_request(lambda: client.post("/api/mdrive/read", json=payload))
         resp.raise_for_status()
         return resp.json().get("content", "")
 
@@ -437,8 +447,7 @@ class MSaplingClient:
     ) -> Dict[str, Any]:
         client = await self._get_client()
         payload: Dict[str, Any] = {
-            "project_id": project_id,
-            "file_path": file_path,
+            "path": _mdrive_scoped_path(project_id, file_path),
             "content": content,
         }
         if agent_id:
@@ -455,9 +464,8 @@ class MSaplingClient:
 
     async def mdrive_delete(self, project_id: str, file_path: str) -> Dict[str, Any]:
         client = await self._get_client()
-        resp = await _retry_request(lambda: client.post(
-            f"/api/mdrive/delete/{project_id}/{file_path}",
-        ))
+        payload = {"path": _mdrive_scoped_path(project_id, file_path)}
+        resp = await _retry_request(lambda: client.post("/api/mdrive/delete", json=payload))
         resp.raise_for_status()
         return resp.json()
 

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/completer.py

@@ -71,6 +71,8 @@ SLASH_COMMANDS: List[str] = [
     "/export",
     "/restore",
     "/permissions",
+    "/sandbox",
+    "/worktree",
 ]
 
 # Commands after which Tab should complete file paths
@@ -81,7 +83,7 @@ _SKIP_DIRS = {".git", "node_modules", "__pycache__", "venv", ".venv", "dist", "b
 
 # Well-known model IDs for offline completion (supplemented at runtime)
 DEFAULT_MODELS: List[str] = [
-    "google/gemini-flash-1.5",
+    "google/gemini-2.0-flash-001",
     "google/gemini-pro-1.5",
     "google/gemini-2.0-flash",
     "anthropic/claude-3-haiku",
@@ -322,6 +324,7 @@ MODEL_ALIASES: dict[str, str] = {
     "gemini flash": "google/gemini-2.0-flash-001",
     "gemini 2.0 flash": "google/gemini-2.0-flash-001",
     "gemini 2 flash": "google/gemini-2.0-flash-001",
+    "gemini 2.5 flash": "google/gemini-2.5-flash-preview-05-20",
     "gemini flash 1.5": "google/gemini-flash-1.5",
     "gemini 1.5 flash": "google/gemini-flash-1.5",
     "gemini pro": "google/gemini-2.0-pro-exp-02-05",
@@ -376,7 +379,7 @@ def resolve_model(user_input: str, available_models: Optional[List[str]] = None)
     """
     raw = user_input.strip()
     if not raw:
-        return "google/gemini-flash-1.5", True
+        return "google/gemini-2.0-flash-001", True
 
     # 1. Exact match (user typed a full ID like "google/gemini-2.0-flash-001")
     if "/" in raw:

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/config.py

@@ -16,7 +16,7 @@ _TOKEN_FILE = _CONFIG_DIR / "token"
 
 class Settings(BaseSettings):
     api_url: str = "https://api.msapling.com"
-    default_model: str = "google/gemini-flash-1.5"
+    default_model: str = "google/gemini-2.0-flash-001"
     max_tokens: int = 4096
     temperature: float = 0.7
     theme: str = "dark"
@@ -48,7 +48,10 @@ def get_token() -> Optional[str]:
 def save_token(token: str) -> None:
     _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     _TOKEN_FILE.write_text(token)
-    _TOKEN_FILE.chmod(0o600)
+    try:
+        _TOKEN_FILE.chmod(0o600)
+    except OSError:
+        pass  # Windows doesn't support Unix permissions
 
 
 def clear_token() -> None:

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/main.py

@@ -301,7 +301,7 @@ def chat(
         client = MSaplingClient()
         try:
             parts = []
-            with Live(console=console, refresh_per_second=15) as live:
+            with Live(console=console, refresh_per_second=8) as live:
                 async for chunk in client.stream_chat(
                     chat_id=chat_id,
                     prompt=msg,

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli/shell.py

@@ -146,6 +146,29 @@ SLASH_HELP = """
 """.strip()
 
 # ─── Hooks System ─────────────────────────────────────────────────────
+# Supported events (matching Claude Code's hook model):
+#   on_session_start    — Shell starts (after auth, before input loop)
+#   on_session_end      — Shell exits (before save)
+#   on_before_message   — Before sending user message to LLM
+#   on_after_message    — After receiving LLM response
+#   on_before_tool      — Before agent executes a tool
+#   on_after_tool       — After agent executes a tool
+#   on_tool_failure     — When a tool execution fails
+#   on_file_write       — After a file is written (by agent or /write)
+#   on_file_read        — After a file is read into context
+#   on_permission_ask   — When user is prompted for tool approval
+#   on_model_change     — When model is switched (/model or agent model_switch)
+#   on_compact           — When context is compacted (/compact)
+#   on_worktree_create  — When a git worktree is created
+#   on_worktree_remove  — When a git worktree is removed
+#   on_subagent_start   — When a background subagent is spawned
+#   on_subagent_done    — When a subagent completes
+#   on_worker_spawn     — When a multi-chat worker is created
+#   on_worker_kill      — When a worker is killed
+#   on_instructions_loaded — When project instructions (.msapling.md) are loaded
+#   on_budget_exceeded  — When cost ceiling is hit
+#   on_config_change    — When a setting is changed
+#   on_cwd_change       — When project root / worktree changes
 
 HOOKS_FILE = Path.home() / ".msapling" / "hooks.json"
 
@@ -271,6 +294,7 @@ class InteractiveShell:
         instructions = _load_project_instructions(self.project_root)
         if instructions:
             self.messages.append({"role": "system", "content": instructions})
+            _run_hooks("on_instructions_loaded", self.hooks, self.project_root)
 
         memories = get_memories(self.project_root)
         if memories:
@@ -303,6 +327,8 @@ class InteractiveShell:
             console.print(f"[dim][hook] {out}[/dim]")
 
         await self._main_loop()
+        for out in _run_hooks("on_session_end", self.hooks, self.project_root):
+            console.print(f"[dim][hook] {out}[/dim]")
         self._save()
         unregister_session(os.getpid())
         console.print("[ms.dim]Session saved. Resume with: msapling shell --resume[/ms.dim]")
@@ -482,6 +508,7 @@ class InteractiveShell:
                 await self._setup_workers(count)
                 if self.workers:
                     self.chat_id = self.workers[0]["chat_id"]
+                    self.model = self.workers[0]["model"]
                     return True
                 continue
 
@@ -624,6 +651,7 @@ class InteractiveShell:
             return True
         if self._total_session_cost() >= self.cost_ceiling:
             console.print(f"[red]Cost ceiling reached (${self.cost_ceiling:.4f}). Use /budget to adjust.[/red]")
+            _run_hooks("on_budget_exceeded", self.hooks, self.project_root)
             return False
         return True
 
@@ -677,11 +705,13 @@ class InteractiveShell:
                     on_text=lambda text: None,
                     on_usage=_on_usage,
                     project_name=self.project_name or "",
+                    chat_id=self.chat_id or "",
                 )
                 if response:
                     render_assistant_response(response)
                     append_conversation(self.project_root, self.session_id, "assistant", response)
                 render_cost_footer(self.tokens_total, self.cost_total)
+                _run_hooks("on_after_message", self.hooks, self.project_root)
 
                 # Check if agent switched models mid-task
                 new_model = get_and_clear_switched_model()
@@ -708,6 +738,8 @@ class InteractiveShell:
 
         try:
             parts = []
+            thinking_parts = []
+            in_thinking = False
             with Live(console=console, refresh_per_second=8) as live:
                 async for chunk in self.client.stream_chat(
                     chat_id=self.chat_id or self.session_id,
@@ -717,14 +749,38 @@ class InteractiveShell:
                     history=history_to_send,
                 ):
                     content = chunk.get("content", "")
+                    # Detect thinking/reasoning blocks (Claude/GPT extended thinking)
+                    chunk_type = chunk.get("type", "")
+                    if chunk_type == "thinking" or chunk.get("thinking"):
+                        thinking_text = chunk.get("thinking", content)
+                        if thinking_text:
+                            thinking_parts.append(thinking_text)
+                            # Show thinking in dim text
+                            from rich.text import Text
+                            thinking_display = Text("".join(thinking_parts), style="dim italic")
+                            live.update(thinking_display)
+                        continue
                     if content:
+                        # If we were showing thinking, clear and switch to main response
+                        if thinking_parts and not parts:
+                            console.print()  # Newline after thinking
                         parts.append(content)
                         live.update(Markdown("".join(parts)))
-                    if chunk.get("type") == "usage":
+                    if chunk_type == "usage" or chunk.get("usage"):
                         usage = chunk.get("usage", {})
                         self.tokens_total += usage.get("total_tokens", 0)
                         self.cost_total += float(chunk.get("cost", 0))
 
+            # Show thinking summary if any
+            if thinking_parts:
+                thinking_text = "".join(thinking_parts)
+                if len(thinking_text) > 200:
+                    console.print(Panel(
+                        f"[dim italic]{thinking_text[:500]}{'...' if len(thinking_text) > 500 else ''}[/dim italic]",
+                        title="[dim]Thinking[/dim]",
+                        border_style="dim",
+                    ))
+
             response = "".join(parts)
             if response:
                 self.messages.append({"role": "assistant", "content": response})
@@ -755,6 +811,7 @@ class InteractiveShell:
                     console.print(f"[ms.accent]Model: {old} -> {self.model}[/ms.accent] [ms.dim](matched from '{args.strip()}')[/ms.dim]")
                 else:
                     console.print(f"[ms.accent]Model: {old} -> {self.model}[/ms.accent]")
+                _run_hooks("on_model_change", self.hooks, self.project_root)
             else:
                 console.print(f"Current model: [ms.accent]{self.model}[/ms.accent]")
         elif command == "/models":
@@ -980,6 +1037,70 @@ class InteractiveShell:
             else:
                 new_mode = set_permission_mode(args.strip().lower())
                 console.print(f"[green]Permission mode: {new_mode}[/green]")
+        elif command == "/worktree":
+            sub = args.split()[0].lower() if args.strip() else "list"
+            wt_arg = args.split()[1] if len(args.split()) > 1 else ""
+            if sub == "list":
+                try:
+                    r = subprocess.run(["git", "worktree", "list"], cwd=self.project_root,
+                                       capture_output=True, text=True, timeout=10)
+                    console.print(r.stdout or "[yellow]No worktrees[/yellow]")
+                except Exception as e:
+                    console.print(f"[red]{e}[/red]")
+            elif sub == "create" and wt_arg:
+                branch = wt_arg
+                wt_path = os.path.join(self.project_root, f"../{Path(self.project_root).name}-{branch}")
+                try:
+                    r = subprocess.run(
+                        ["git", "worktree", "add", wt_path, "-b", branch],
+                        cwd=self.project_root, capture_output=True, text=True, timeout=30,
+                    )
+                    if r.returncode == 0:
+                        console.print(f"[green]Worktree created: {wt_path}[/green]")
+                        console.print(f"[dim]Switch with: /worktree switch {branch}[/dim]")
+                    else:
+                        console.print(f"[red]{r.stderr}[/red]")
+                except Exception as e:
+                    console.print(f"[red]{e}[/red]")
+            elif sub == "switch" and wt_arg:
+                try:
+                    r = subprocess.run(["git", "worktree", "list", "--porcelain"],
+                                       cwd=self.project_root, capture_output=True, text=True, timeout=10)
+                    for line in r.stdout.split("\n"):
+                        if line.startswith("worktree ") and wt_arg in line:
+                            new_root = line.replace("worktree ", "").strip()
+                            self.project_root = new_root
+                            console.print(f"[green]Switched to worktree: {new_root}[/green]")
+                            break
+                    else:
+                        console.print(f"[yellow]Worktree not found: {wt_arg}[/yellow]")
+                except Exception as e:
+                    console.print(f"[red]{e}[/red]")
+            elif sub == "delete" and wt_arg:
+                try:
+                    r = subprocess.run(["git", "worktree", "remove", wt_arg],
+                                       cwd=self.project_root, capture_output=True, text=True, timeout=10)
+                    if r.returncode == 0:
+                        console.print(f"[green]Worktree removed: {wt_arg}[/green]")
+                    else:
+                        console.print(f"[red]{r.stderr}[/red]")
+                except Exception as e:
+                    console.print(f"[red]{e}[/red]")
+            else:
+                console.print("[yellow]Usage: /worktree <create|list|switch|delete> [branch][/yellow]")
+        elif command == "/sandbox":
+            from .agent import set_sandbox, _sandbox_enabled
+            if not args.strip():
+                status = "[green]ON[/green]" if _sandbox_enabled else "[red]OFF[/red]"
+                console.print(f"[cyan]Command sandbox:[/cyan] {status}")
+                console.print("[dim]  Blocks dangerous commands (rm -rf /, sudo, curl|bash, etc.)")
+                console.print("  /sandbox off  — disable  |  /sandbox on  — enable[/dim]")
+            elif args.strip().lower() in ("on", "true", "1"):
+                set_sandbox(True)
+                console.print("[green]Sandbox: ON[/green]")
+            elif args.strip().lower() in ("off", "false", "0"):
+                set_sandbox(False)
+                console.print("[yellow]Sandbox: OFF — dangerous commands allowed[/yellow]")
         elif command == "/simple":
             self.agent_mode = False
             console.print("Mode: [yellow]Simple[/yellow]")

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msapling-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: MSapling CLI - Multi-chat AI development environment in your terminal
 Author: MSapling Team
 License-Expression: MIT
@@ -31,9 +31,12 @@ Provides-Extra: keyring
 Requires-Dist: keyring>=24.0; extra == "keyring"
 Provides-Extra: tui
 Requires-Dist: textual>=0.40.0; extra == "tui"
+Provides-Extra: pdf
+Requires-Dist: pdfplumber>=0.10.0; extra == "pdf"
 Provides-Extra: all
 Requires-Dist: keyring>=24.0; extra == "all"
 Requires-Dist: textual>=0.40.0; extra == "all"
+Requires-Dist: pdfplumber>=0.10.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: build>=1.2.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/msapling_cli.egg-info/requires.txt

@@ -10,6 +10,7 @@ pyreadline3>=3.4
 [all]
 keyring>=24.0
 textual>=0.40.0
+pdfplumber>=0.10.0
 
 [dev]
 build>=1.2.0
@@ -20,5 +21,8 @@ twine>=5.0.0
 [keyring]
 keyring>=24.0
 
+[pdf]
+pdfplumber>=0.10.0
+
 [tui]
 textual>=0.40.0

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "msapling-cli"
-version = "0.1.3"
+version = "0.1.4"
 description = "MSapling CLI - Multi-chat AI development environment in your terminal"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -35,7 +35,8 @@ dependencies = [
 [project.optional-dependencies]
 keyring = ["keyring>=24.0"]
 tui = ["textual>=0.40.0"]
-all = ["keyring>=24.0", "textual>=0.40.0"]
+pdf = ["pdfplumber>=0.10.0"]
+all = ["keyring>=24.0", "textual>=0.40.0", "pdfplumber>=0.10.0"]
 dev = ["build>=1.2.0", "pytest>=8.0", "pytest-asyncio>=0.23", "twine>=5.0.0"]
 
 [project.scripts]

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/tests/test_agent.py

@@ -151,7 +151,7 @@ def test_safe_path_blocks_prefixed_sibling(tmp_path):
 
 
 def test_tools_schema_complete():
-    assert len(AGENT_TOOLS_SCHEMA) == 7
+    assert len(AGENT_TOOLS_SCHEMA) == 14
     names = {tool["name"] for tool in AGENT_TOOLS_SCHEMA}
     assert "read_file" in names
     assert "write_file" in names
@@ -159,6 +159,13 @@ def test_tools_schema_complete():
     assert "run_command" in names
     assert "glob_files" in names
     assert "grep_search" in names
+    assert "cost_check" in names
+    assert "model_switch" in names
+    assert "search_replace_all" in names
+    assert "todo_list" in names
+    assert "ask_user" in names
+    assert "list_directory" in names
+    assert "web_fetch" in names
 
 
 def test_max_steps_bounded():

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/tests/test_api.py

@@ -117,3 +117,43 @@ async def test_projects_overview_falls_back_to_legacy_projects():
     assert overview["projects"][0]["name"] == "Default Project"
     assert overview["projects"][0]["chat_limit"] == 10
     assert overview["projects"][1]["chat_limit"] == 6
+
+
+@pytest.mark.asyncio
+async def test_mdrive_write_uses_scoped_path_payload():
+    client = MSaplingClient(api_url="http://test:8000", token="test-token")
+    response = MagicMock()
+    response.status_code = 200
+    response.raise_for_status = MagicMock()
+    response.json.return_value = {"status": "success"}
+
+    mock_client = AsyncMock()
+    mock_client.post = AsyncMock(return_value=response)
+
+    with patch.object(client, "_get_client", AsyncMock(return_value=mock_client)):
+        result = await client.mdrive_write("Default Project", "src/app.py", "print(1)")
+
+    assert result == {"status": "success"}
+    _, kwargs = mock_client.post.call_args
+    assert kwargs["json"]["path"] == "Default Project/src/app.py"
+    assert kwargs["json"]["content"] == "print(1)"
+
+
+@pytest.mark.asyncio
+async def test_list_project_chats_uses_trailing_slash():
+    client = MSaplingClient(api_url="http://test:8000", token="test-token")
+    response = MagicMock()
+    response.status_code = 200
+    response.raise_for_status = MagicMock()
+    response.json.return_value = {"projects": {"Default Project": {"chats": [{"id": "1"}]}}}
+
+    mock_client = AsyncMock()
+    mock_client.get = AsyncMock(return_value=response)
+
+    with patch.object(client, "_get_client", AsyncMock(return_value=mock_client)):
+        chats = await client.list_project_chats("Default Project")
+
+    assert chats == [{"id": "1"}]
+    args, kwargs = mock_client.get.call_args
+    assert args[0] == "/api/projects/"
+    assert kwargs["params"] == {"limit": 100}

{msapling_cli-0.1.3 → msapling_cli-0.1.4}/tests/test_config.py

@@ -10,7 +10,7 @@ from msapling_cli.config import Settings, get_settings, save_settings, get_token
 def test_default_settings():
     s = Settings()
     assert s.api_url == "https://api.msapling.com"
-    assert s.default_model == "google/gemini-flash-1.5"
+    assert s.default_model == "google/gemini-2.0-flash-001"
     assert s.temperature == 0.7
     assert s.theme == "dark"