sky-dev 0.1.9__tar.gz → 0.1.14__tar.gz

{sky_dev-0.1.9 → sky_dev-0.1.14}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.1.14] - 2026-10-06
+
+### Fixed
+- Workflow crash: "No module named 'sky.tools.test_tools'"
+- Workflow hang: 60s timeout added to LLM calls
+- Guardrails crash: "Missing credentials" when API key absent
+- Router now lazily loads provider clients on first use
+- Error messages now reference correct env var name (`NVIDIA_NIM_API_KEY`)
+- `.env` reloaded dynamically for late-loaded keys
+- Client rotation on HTTP 429 rate limit
+
+### Changed
+- Lazy provider initialization (no eager client creation)
+- Graceful Ctrl+C handling during workflow
+- Elapsed time shown for each workflow step
+
+### UI
+- Replaced cloud logo with SKY ASCII art
+- Added username in header (from sky init)
+- Removed model and working directory from chat header
+
+## [0.1.10] - 2026-09-28
+
+### Added
+- Claude-style beautiful terminal UI components (`sky.ui`)
+- Clean ASCII art logo (Option B)
+- Personalized username configuration (`sky init` asks for username)
+
+### Fixed
+- Fixed NVIDIA Guardrails 404 Error by adding a runtime model health-check verification
+- Fixed visual clipping by removing model and working directory from the chat header
+
 ## [0.1.9] - 2026-09-28
 
 ### Added

{sky_dev-0.1.9 → sky_dev-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sky-dev
-Version: 0.1.9
+Version: 0.1.14
 Summary: Sky - Agentic coding assistant. Build without boundaries.
 Author-email: Aaditya A <aaditya@corover.ai>
 License: MIT

{sky_dev-0.1.9 → sky_dev-0.1.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sky-dev"
-version = "0.1.9"
+version = "0.1.14"
 description = "Sky - Agentic coding assistant. Build without boundaries."
 readme = "README.md"
 license = {text = "MIT"}

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/__init__.py

@@ -1,6 +1,6 @@
 """Sky - Build without boundaries."""
 
-__version__ = "0.1.9"
+__version__ = "0.1.14"
 __author__ = "Aaditya A"
 __author_email__ = "aaditya@corover.ai"
 __description__ = "Local, CLI-based, agentic software development assistant"

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/cli.py

@@ -22,6 +22,7 @@ import typer
 from rich.console import Console
 
 from sky import __version__
+from sky.ui import render_header, render_message, render_thinking, render_tool_call, render_diff, render_permission
 
 app = typer.Typer(help="SKY - Local CLI-based agentic software development assistant")
 console = Console()
@@ -238,6 +239,19 @@ def chat(
 
     Created by Aaditya A (AI/ML Intern at CoRover.ai)
     """
+    render_header(
+        version=__version__,
+        tips=[
+            "Ask Sky to explain your code",
+            "Try: sky plan 'add feature X'",
+            "Use sky agent for full execution",
+        ],
+        whats_new=[
+            "Added NVIDIA Guardrails",
+            "Faster CLI startup",
+            "Dynamic model discovery",
+        ],
+    )
     from sky.config import load_config, load_models_config
     from sky.storage import get_db
     from sky.core.router import ModelRouter
@@ -689,6 +703,17 @@ def init(
         
     from sky.config.schema import get_config_dir
     config_dir = get_config_dir(global_mode=global_install)
+    
+    import json
+    import os
+    default_user = os.getenv("USER") or os.getenv("USERNAME") or "Developer"
+    username = Prompt.ask("What should Sky call you?", default=default_user)
+    
+    config_dir.mkdir(parents=True, exist_ok=True)
+    user_config = config_dir / "user.json"
+    with open(user_config, "w") as f:
+        json.dump({"username": username}, f)
+    console.print(f"[green]✅ Username saved: {username}[/green]")
         
     def _save_env(groq_key: str, nim_key: str):
         with open(config_dir / ".env", "w") as f:
@@ -833,7 +858,7 @@ def validate_model(provider: str, model_id: str) -> bool:
             except:
                 pass
     elif provider == "nim":
-        key = os.getenv("NIM_API_KEY")
+        key = os.getenv("NVIDIA_NIM_API_KEY")
         if key:
             try:
                 res = httpx.get("https://integrate.api.nvidia.com/v1/models", headers={"Authorization": f"Bearer {key}"})

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/core/chat.py

@@ -71,11 +71,7 @@ class ChatEngine:
             self.console.print("[yellow]⚠️ No API keys found. Run 'sky init' first.[/yellow]")
             return
             
-        self.console.print(Panel(
-            Markdown(self.get_welcome_message()),
-            title="☁️ Sky Chat",
-            border_style="cyan"
-        ))
+        # Welcome message is now rendered by SkyHeader in cli.py
         
         if initial_prompt:
             self._process_user_message(initial_prompt)

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/core/router.py

@@ -14,6 +14,16 @@ class ModelRouter:
 
     def __init__(self, config: ModelRoutingConfig, db: DatabaseManager, session_id: str):
         import os
+        from dotenv import load_dotenv
+        from sky.config.schema import get_config_dir
+        
+        # Load .env
+        env_path = get_config_dir() / ".env"
+        if env_path.exists():
+            load_dotenv(env_path)
+        else:
+            load_dotenv()
+            
         self.config = config
         self.db = db
         self.session_id = session_id
@@ -22,42 +32,57 @@ class ModelRouter:
         self.provider_keys = {}
         self.current_key_idx = {}
         
-        for provider_name, provider_config in self.config.providers.items():
-            if provider_config.requires_api_key:
-                # Find keys for this provider, e.g., GROQ_API_KEY, NIM_API_KEY
-                env_prefix = "NVIDIA_NIM" if provider_name == "nim" else provider_name.upper()
-                keys = []
-                for key_name in [f"{env_prefix}_API_KEY", f"{env_prefix}_API_KEY_2", f"{env_prefix}_API_KEY_3"]:
-                    key = os.getenv(key_name)
-                    if key:
-                        keys.append(key)
-                if not keys:
-                    # Log a warning, but don't crash unless they try to use it
-                    pass
-                else:
-                    self.provider_keys[provider_name] = keys
-                    self.current_key_idx[provider_name] = 0
-            else:
-                self.provider_keys[provider_name] = ["dummy"]
-                self.current_key_idx[provider_name] = 0
-                
-            self._init_client(provider_name)
+    def _get_client(self, provider_name: str) -> Any:
+        """Get or initialize the client for a specific provider."""
+        import os
         
-    def _init_client(self, provider_name: str):
-        """Initialize the client for a specific provider."""
+        if provider_name in self.clients:
+            return self.clients[provider_name]
+            
         provider_config = self.config.providers.get(provider_name)
         if not provider_config:
-            return
+            return None
+            
+        if provider_config.requires_api_key:
+            env_prefix = "NVIDIA_NIM" if provider_name == "nim" else provider_name.upper()
+            keys = []
+            for key_name in [f"{env_prefix}_API_KEY", f"{env_prefix}_API_KEY_2", f"{env_prefix}_API_KEY_3"]:
+                key = os.getenv(key_name)
+                if key:
+                    keys.append(key)
+            if not keys:
+                return None
+                
+            self.provider_keys[provider_name] = keys
+            self.current_key_idx[provider_name] = 0
+            api_key = keys[0]
+        else:
+            self.provider_keys[provider_name] = ["dummy"]
+            self.current_key_idx[provider_name] = 0
+            api_key = "dummy"
             
+        kwargs = {
+            "api_key": api_key,
+            "timeout": httpx.Timeout(provider_config.timeout)
+        }
+        if provider_config.base_url:
+            kwargs["base_url"] = provider_config.base_url
+            
+        self.clients[provider_name] = AsyncOpenAI(**kwargs)
+        return self.clients[provider_name]
+
+    def _rotate_client(self, provider_name: str):
+        """Rotate to the next API key and reinitialize the client."""
         keys = self.provider_keys.get(provider_name, [])
-        if not keys:
+        if len(keys) <= 1:
             return
             
-        idx = self.current_key_idx.get(provider_name, 0)
-        api_key = keys[idx]
+        next_idx = (self.current_key_idx[provider_name] + 1) % len(keys)
+        self.current_key_idx[provider_name] = next_idx
         
+        provider_config = self.config.providers.get(provider_name)
         kwargs = {
-            "api_key": api_key,
+            "api_key": keys[next_idx],
             "timeout": httpx.Timeout(provider_config.timeout)
         }
         if provider_config.base_url:
@@ -106,12 +131,13 @@ class ModelRouter:
         """Call API, rotating keys if rate limit is hit."""
         from rich.console import Console
         
-        client = self.clients.get(provider_name)
+        client = self._get_client(provider_name)
         if not client:
+            env_prefix = "NVIDIA_NIM" if provider_name == "nim" else provider_name.upper()
             raise ConfigurationError(
                 f"No active client for provider: {provider_name}.",
                 code="SKY-001",
-                suggestion=f"Add {provider_name.upper()}_API_KEY to .env or run `sky init`"
+                suggestion=f"Add {env_prefix}_API_KEY to .env or run `sky init`"
             )
             
         keys = self.provider_keys.get(provider_name, [])
@@ -127,8 +153,7 @@ class ModelRouter:
                     if len(keys) > 1:
                         next_idx = (self.current_key_idx[provider_name] + 1) % len(keys)
                         Console().print(f"[yellow]{provider_name.upper()} API key rate limited. Rotating to next key (slot {next_idx + 1}/{len(keys)})...[/yellow]")
-                        self.current_key_idx[provider_name] = next_idx
-                        self._init_client(provider_name)
+                        self._rotate_client(provider_name)
                         client = self.clients[provider_name]
                     else:
                         break

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/core/workflow.py

@@ -7,6 +7,9 @@ import json
 import logging
 from pathlib import Path
 import asyncio
+import time
+import typer
+from rich.console import Console
 
 from langgraph.graph import StateGraph, END
 from langgraph.checkpoint.sqlite import SqliteSaver
@@ -21,7 +24,7 @@ from sky.core.subagent import SubagentRunner, SubagentRole
 from sky.memory.indexer import RepoIndexer
 
 logger = logging.getLogger(__name__)
-
+console = Console()
 
 class WorkflowStatus(str, Enum):
     """Workflow execution status."""
@@ -154,9 +157,21 @@ class WorkflowEngine:
             import asyncio
             if isinstance(self.event_queue, asyncio.Queue):
                 await self.event_queue.put(event)
+
+    async def _call_model_with_timeout(self, role, messages, timeout=60):
+        try:
+            return await asyncio.wait_for(
+                self.router.route(role, messages, expected_tool_calls=0),
+                timeout=timeout
+            )
+        except asyncio.TimeoutError:
+            logger.error(f"Model call timed out after {timeout}s")
+            return {}, False, None
     
     async def _refine_goal(self, state: WorkflowState) -> WorkflowState:
         """Refine the user's goal using the planning model."""
+        start = time.time()
+        console.print("[dim]Refining goal...[/dim]")
         await self._emit({"type": "step", "step": "refining", "message": "🎯 Refining goal..."})
         logger.info("Refining goal...")
         
@@ -172,11 +187,10 @@ Be specific about what files or components might be involved."""},
             {"role": "user", "content": state["user_goal"]}
         ]
         
-        response, was_fallback, model_used = await self.router.route(
-            "planning",
-            messages,
-            expected_tool_calls=0,
-        )
+        response, was_fallback, model_used = await self._call_model_with_timeout("planning", messages)
+        
+        elapsed = time.time() - start
+        console.print(f"[dim]Refined in {elapsed:.1f}s[/dim]")
         
         content = response.get("content", "")
         
@@ -192,7 +206,7 @@ Be specific about what files or components might be involved."""},
             else:
                 state["refined_goal"] = content
                 state["goal_confidence"] = 0.5
-        except json.JSONDecodeError:
+        except Exception:
             state["refined_goal"] = content
             state["goal_confidence"] = 0.5
         
@@ -202,6 +216,8 @@ Be specific about what files or components might be involved."""},
     
     async def _decompose(self, state: WorkflowState) -> WorkflowState:
         """Decompose the goal into subtasks."""
+        start = time.time()
+        console.print("[dim]Breaking down into tasks...[/dim]")
         await self._emit({"type": "step", "step": "decomposing", "message": "Breaking down into tasks..."})
         logger.info("Decomposing goal into tasks...")
         
@@ -229,11 +245,10 @@ CRITICAL RULES:
             {"role": "user", "content": f"Goal: {state.get('refined_goal', state['user_goal'])}"}
         ]
         
-        response, was_fallback, model_used = await self.router.route(
-            "planning",
-            messages,
-            expected_tool_calls=0,
-        )
+        response, was_fallback, model_used = await self._call_model_with_timeout("planning", messages)
+        
+        elapsed = time.time() - start
+        console.print(f"[dim]Decomposed in {elapsed:.1f}s[/dim]")
         
         content = response.get("content", "")
         
@@ -254,7 +269,7 @@ CRITICAL RULES:
                     "tools_needed": ["read_file", "write_file", "edit_file", "run_tests"],
                     "role": "coder"
                 }]
-        except json.JSONDecodeError:
+        except Exception:
             state["tasks"] = [{
                 "id": "task_1",
                 "description": state.get("refined_goal", state["user_goal"]),
@@ -363,41 +378,39 @@ CRITICAL RULES:
     
     async def _run_tests(self, state: WorkflowState) -> WorkflowState:
         """Run tests after code changes."""
+        start = time.time()
+        console.print("[dim]Running tests...[/dim]")
         await self._emit({"type": "step", "step": "testing", "message": "Running tests..."})
         logger.info("Running tests...")
         
-        # Collect any test-related changes
-        test_files = []
-        for result in state.get("subagent_results", []):
-            if result.get("test_results"):
-                test_files.extend(result.get("test_files", []))
-        
-        # Run tests using the test tool
-        from sky.tools.test_tools import run_tests
+        from sky.tools.test_tools import run_tests  # Direct import — no fallback
         
         try:
-            # run_tests returns a dict matching exactly what we need
             result = run_tests(timeout=120)
+            state["test_results"] = result
             
-            state["test_results"] = {
-                "passed": result.get("passed", 0),
-                "failed": result.get("failed", 0),
-                "errors": result.get("errors", []),
-                "success": result.get("success", False)
-            }
-            state["status"] = WorkflowStatus.TESTING.value
+            if result.get("framework") == "none":
+                console.print(f"[yellow]⚠️  {result.get('error', 'No test framework detected')}[/yellow]")
+            elif result.get("success"):
+                console.print(f"[green]✅ {result['passed']} passed[/green]")
+            else:
+                console.print(f"[red]❌ {result['failed']} failed, {result['passed']} passed[/red]")
         except Exception as e:
+            logger.error(f"Test execution failed: {e}")
             state["test_results"] = {
-                "passed": 0,
-                "failed": 1,
-                "errors": [str(e)],
-                "success": False
+                "error": str(e),
+                "success": False,
             }
         
+        elapsed = time.time() - start
+        console.print(f"[dim]Tests completed in {elapsed:.1f}s[/dim]")
+        state["status"] = WorkflowStatus.TESTING.value
         return state
     
     async def _reflect(self, state: WorkflowState) -> WorkflowState:
         """Reflect on test results and decide next action."""
+        start = time.time()
+        console.print("[dim]Reflecting on results...[/dim]")
         await self._emit({"type": "step", "step": "reflecting", "message": "Reflecting on results..."})
         logger.info("Reflecting on results...")
         
@@ -452,11 +465,10 @@ Failed tasks: {[t for t in state['task_status'] if state['task_status'][t] == 'f
 Provide analysis and suggested fixes."""}
         ]
         
-        response, was_fallback, model_used = await self.router.route(
-            "planning",
-            messages,
-            expected_tool_calls=0,
-        )
+        response, was_fallback, model_used = await self._call_model_with_timeout("planning", messages)
+        
+        elapsed = time.time() - start
+        console.print(f"[dim]Reflected in {elapsed:.1f}s[/dim]")
         
         content = response.get("content", "")
         
@@ -475,7 +487,7 @@ Provide analysis and suggested fixes."""}
                 for task_id, status in state["task_status"].items():
                     if status == "failed":
                         state["task_status"][task_id] = "pending"
-        except json.JSONDecodeError:
+        except Exception:
             # Fallback: retry failed tasks
             for task_id, status in state["task_status"].items():
                 if status == "failed":
@@ -506,6 +518,8 @@ Provide analysis and suggested fixes."""}
     
     async def _summarize(self, state: WorkflowState) -> WorkflowState:
         """Generate final summary."""
+        start = time.time()
+        console.print("[dim]Generating summary...[/dim]")
         await self._emit({"type": "step", "step": "summarizing", "message": "Generating summary..."})
         logger.info("Generating summary...")
         
@@ -546,11 +560,10 @@ Test Results: {json.dumps(test_results, indent=2)}
 Create a summary of the work."""}
         ]
         
-        response, was_fallback, model_used = await self.router.route(
-            "planning",
-            messages,
-            expected_tool_calls=0,
-        )
+        response, was_fallback, model_used = await self._call_model_with_timeout("planning", messages)
+        
+        elapsed = time.time() - start
+        console.print(f"[dim]Summarized in {elapsed:.1f}s[/dim]")
         
         content = response.get("content", "")
         
@@ -558,6 +571,12 @@ Create a summary of the work."""}
             state["status"] = WorkflowStatus.COMPLETED.value
             
         await self._emit({"type": "complete", "summary": content})
+        
+        console.print()
+        console.print(f"[bold green]✅ Workflow Complete![/bold green]")
+        if state.get("test_results", {}).get("skipped"):
+            console.print("[dim]Note: Tests were skipped[/dim]")
+        console.print()
             
         return state
     
@@ -641,9 +660,13 @@ Create a summary of the work."""}
                 if snapshot:
                     state = snapshot.values
             
-            # Execute asynchronously
-            async for event in app.astream(state, config):
-                pass
+            try:
+                # Execute asynchronously
+                async for event in app.astream(state, config):
+                    pass
+            except (KeyboardInterrupt, asyncio.CancelledError):
+                console.print("\n[yellow]Workflow interrupted. Progress saved to checkpoint.[/yellow]")
+                raise typer.Exit(0)
                 
             # Get final state
             final_state_snapshot = await app.aget_state(config)

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/errors.py

@@ -35,7 +35,7 @@ ERROR_MESSAGES = {
         "message": "🔑 Groq API key not found.",
         "suggestion": "Run `sky init` to set up your API keys, or add GROQ_API_KEY to .env"
     },
-    "NIM_API_KEY_MISSING": {
+    "NVIDIA_NIM_API_KEY_MISSING": {
         "message": "🔑 NVIDIA NIM API key not found.",
         "suggestion": "Run `sky init` to set up your API keys, or add NVIDIA_NIM_API_KEY to .env"
     },

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky/security/guardrails_nvidia.py

@@ -18,38 +18,7 @@ PREFERRED_MODELS = [
     "mistralai/mistral-large-2-instruct",       # Alternative
 ]
 
-def discover_guardrail_model() -> Optional[str]:
-    """Discover an available model from NVIDIA NIM."""
-    api_key = os.getenv("NVIDIA_NIM_API_KEY")
-    if not api_key:
-        return None
-    
-    try:
-        res = httpx.get(
-            "https://integrate.api.nvidia.com/v1/models",
-            headers={"Authorization": f"Bearer {api_key}"},
-            timeout=10
-        )
-        available = {m["id"] for m in res.json().get("data", [])}
-        
-        # Pick the first preferred model that's available
-        for model in PREFERRED_MODELS:
-            if model in available:
-                logger.info(f"Using guardrail model: {model}")
-                return model
-        
-        # Fallback: any Llama or Nemotron model
-        for model_id in available:
-            if "llama" in model_id.lower() or "nemotron" in model_id.lower():
-                logger.info(f"Fallback guardrail model: {model_id}")
-                return model_id
-        
-        logger.warning("No suitable guardrail model found")
-        return None
-    except Exception as e:
-        logger.error(f"Model discovery failed: {e}")
-        return None
-
+_verified_model_cache: Optional[str] = None
 
 class NVIDIAGuardrails:
     """NVIDIA NIM Guardrails wrapper with async parallel support."""
@@ -66,19 +35,98 @@ class NVIDIAGuardrails:
         if getattr(self, "_initialized", False):
             return
         
+        # Load .env
+        from dotenv import load_dotenv
+        from sky.config.schema import get_config_dir
+        env_path = get_config_dir() / ".env"
+        if env_path.exists():
+            load_dotenv(env_path)
+        else:
+            load_dotenv()
+        
+        api_key = os.getenv("NVIDIA_NIM_API_KEY")
+        
+        if not api_key:
+            logger.warning("NVIDIA_NIM_API_KEY not set — guardrails disabled")
+            self.client = None
+            self.model = None
+            self._initialized = True
+            return
+        
         self.client = AsyncOpenAI(
             base_url="https://integrate.api.nvidia.com/v1",
-            api_key=os.getenv("NVIDIA_NIM_API_KEY")
+            api_key=api_key
         )
-        self.model = discover_guardrail_model()
+        self.model: Optional[str] = None
         self._initialized = True
+        
+    async def _verify_model(self, model_id: str) -> bool:
+        """Verify the model actually works with this account."""
+        try:
+            response = await self.client.chat.completions.create(
+                model=model_id,
+                messages=[{"role": "user", "content": "hi"}],
+                max_tokens=1,
+                timeout=5,
+            )
+            return response is not None
+        except Exception as e:
+            logger.debug(f"Model {model_id} verification failed: {e}")
+            return False
+
+    async def discover_guardrail_model(self) -> Optional[str]:
+        """Discover a model that actually works with this account."""
+        api_key = os.getenv("NVIDIA_NIM_API_KEY")
+        if not api_key:
+            return None
+        
+        try:
+            res = httpx.get(
+                "https://integrate.api.nvidia.com/v1/models",
+                headers={"Authorization": f"Bearer {api_key}"},
+                timeout=10,
+            )
+            available = {m["id"] for m in res.json().get("data", [])}
+            
+            for model in PREFERRED_MODELS:
+                if model in available:
+                    # Verify the model actually works
+                    if await self._verify_model(model):
+                        logger.info(f"Using verified guardrail model: {model}")
+                        return model
+                    else:
+                        logger.warning(f"Model {model} listed but not accessible — trying next")
+            
+            # Fallback: any llama/nemotron model that verifies
+            for model_id in available:
+                if "llama" in model_id.lower() or "nemotron" in model_id.lower():
+                    if await self._verify_model(model_id):
+                        logger.info(f"Fallback verified model: {model_id}")
+                        return model_id
+            
+            logger.warning("No verifiable guardrail model found")
+            return None
+        except Exception as e:
+            logger.error(f"Model discovery failed: {e}")
+            return None
+
+    async def get_verified_model(self) -> Optional[str]:
+        """Get cached verified model, discover if needed."""
+        global _verified_model_cache
+        if _verified_model_cache is not None:
+            self.model = _verified_model_cache
+            return _verified_model_cache
+        _verified_model_cache = await self.discover_guardrail_model()
+        self.model = _verified_model_cache
+        return _verified_model_cache
     
     def is_available(self) -> bool:
-        """Check if NVIDIA guardrails are available."""
-        return bool(self.model)
+        """Check if NVIDIA guardrails are actually usable."""
+        return self.client is not None and self.model is not None
     
     async def check_input_async(self, user_input: str) -> Dict[str, Any]:
         """Async check for jailbreak attempts."""
+        await self.get_verified_model()
         if not self.is_available():
             return {"passed": True, "reason": "NVIDIA unavailable", "layer": "nvidia"}
         
@@ -116,6 +164,7 @@ class NVIDIAGuardrails:
     
     async def check_topic_async(self, user_input: str) -> Dict[str, Any]:
         """Async check for on-topic content."""
+        await self.get_verified_model()
         if not self.is_available():
             return {"passed": True, "reason": "NVIDIA unavailable", "layer": "nvidia"}
         
@@ -152,6 +201,7 @@ class NVIDIAGuardrails:
     
     async def check_response_async(self, response: str) -> Dict[str, Any]:
         """Async check for unsafe content in model responses."""
+        await self.get_verified_model()
         if not self.is_available():
             return {"passed": True, "reason": "NVIDIA unavailable", "layer": "nvidia"}
         

sky_dev-0.1.14/sky/tools/test_tools.py

@@ -0,0 +1,315 @@
+import json
+import re
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import logging
+import xml.etree.ElementTree as ET
+
+from sky.tools.registry import register_tool, RiskTier
+
+logger = logging.getLogger(__name__)
+
+def _detect_test_framework(project_root: Path) -> Optional[str]:
+    """Detect the testing framework used in the project."""
+    # Check for pytest
+    if (project_root / "pytest.ini").exists():
+        return "pytest"
+    if (project_root / "pyproject.toml").exists():
+        content = (project_root / "pyproject.toml").read_text()
+        if "[tool.pytest]" in content:
+            return "pytest"
+    if (project_root / "setup.cfg").exists():
+        content = (project_root / "setup.cfg").read_text()
+        if "[tool:pytest]" in content:
+            return "pytest"
+    
+    # Check for pytest or unittest in tests/
+    tests_dir = project_root / "tests"
+    if tests_dir.exists() and tests_dir.is_dir():
+        for file in tests_dir.glob("test_*.py"):
+            content = file.read_text()
+            if "pytest" in content:
+                return "pytest"
+            if "unittest" in content:
+                return "unittest"
+        return "unittest" # Default if tests/test_*.py exist but no specific imports
+
+    # Check for npm
+    if (project_root / "package.json").exists():
+        content = json.loads((project_root / "package.json").read_text())
+        if "test" in content.get("scripts", {}):
+            return "npm"
+            
+    # Check for cargo
+    if (project_root / "Cargo.toml").exists():
+        return "cargo"
+        
+    # Check for go
+    if (project_root / "go.mod").exists():
+        return "go"
+
+    return None
+
+def _detect_linter(project_root: Path) -> Optional[str]:
+    """Detect the linter used in the project."""
+    # Check for ruff
+    if (project_root / "ruff.toml").exists():
+        return "ruff"
+    if (project_root / "pyproject.toml").exists():
+        content = (project_root / "pyproject.toml").read_text()
+        if "[tool.ruff]" in content:
+            return "ruff"
+
+    # Check for flake8
+    if (project_root / ".flake8").exists():
+        return "flake8"
+    if (project_root / "setup.cfg").exists():
+        content = (project_root / "setup.cfg").read_text()
+        if "[flake8]" in content:
+            return "flake8"
+    if (project_root / "tox.ini").exists():
+        content = (project_root / "tox.ini").read_text()
+        if "[flake8]" in content:
+            return "flake8"
+
+    # Check for eslint
+    if (project_root / "package.json").exists():
+        content = json.loads((project_root / "package.json").read_text())
+        if "eslint" in content.get("devDependencies", {}) or "eslint" in content.get("dependencies", {}):
+            return "eslint"
+    if any(project_root.glob(".eslintrc*")):
+        return "eslint"
+
+    return None
+
+def _parse_junitxml(xml_path: Path) -> Dict[str, Any]:
+    """Parse pytest JUnit output."""
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    
+    testsuite = root if root.tag == "testsuite" else root.find("testsuite")
+    if testsuite is None:
+        return {"error": "Invalid JUnit XML format"}
+
+    errors_list = []
+    for testcase in testsuite.findall("testcase"):
+        failure = testcase.find("failure")
+        if failure is not None:
+            errors_list.append(failure.text or failure.get("message", "Unknown error"))
+        error = testcase.find("error")
+        if error is not None:
+            errors_list.append(error.text or error.get("message", "Unknown error"))
+
+    return {
+        "passed": int(testsuite.get("tests", 0)) - int(testsuite.get("failures", 0)) - int(testsuite.get("errors", 0)) - int(testsuite.get("skipped", 0)),
+        "failed": int(testsuite.get("failures", 0)) + int(testsuite.get("errors", 0)),
+        "skipped": int(testsuite.get("skipped", 0)),
+        "total": int(testsuite.get("tests", 0)),
+        "errors": errors_list
+    }
+
+def _parse_pytest_output(stdout: str) -> Dict[str, Any]:
+    """Fallback parser if JUnitXML unavailable."""
+    passed = 0
+    failed = 0
+    skipped = 0
+    
+    # Look for the summary line: e.g. "== 1 passed, 2 failed in 0.12s =="
+    summary_match = re.search(r'==.*?(\d+)\s+passed.*?==', stdout)
+    if summary_match:
+        passed = int(summary_match.group(1))
+        
+    failed_match = re.search(r'==.*?(\d+)\s+failed.*?==', stdout)
+    if failed_match:
+        failed = int(failed_match.group(1))
+
+    skipped_match = re.search(r'==.*?(\d+)\s+skipped.*?==', stdout)
+    if skipped_match:
+        skipped = int(skipped_match.group(1))
+
+    return {
+        "passed": passed,
+        "failed": failed,
+        "skipped": skipped,
+        "total": passed + failed + skipped,
+        "errors": [line for line in stdout.split('\n') if "FAILED" in line or "ERROR" in line]
+    }
+
+def _truncate(text: str, max_len: int = 2000) -> str:
+    """Truncate long output."""
+    if len(text) <= max_len:
+        return text
+    return text[:max_len//2] + "\n...[truncated]...\n" + text[-max_len//2:]
+
+@register_tool(
+    name="run_tests",
+    description="Auto-detect and run the project's test suite, returning structured results",
+    risk_tier=RiskTier.SAFE,
+)
+def run_tests(target: Optional[str] = None, timeout: int = 120) -> Dict[str, Any]:
+    """Run tests and return structured results."""
+    project_root = Path.cwd()
+    framework = _detect_test_framework(project_root)
+    
+    if not framework:
+        return {"framework": "none", "error": "No test framework detected", "success": False}
+
+    target_str = target if target else ""
+    start_time = time.time()
+    result = {
+        "framework": framework,
+        "passed": 0,
+        "failed": 0,
+        "errors": [],
+        "skipped": 0,
+        "total": 0,
+        "success": False,
+        "duration_seconds": 0.0,
+        "output": ""
+    }
+
+    try:
+        if framework == "pytest":
+            with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as tmp:
+                xml_path = tmp.name
+            
+            cmd = f"python -m pytest {target_str} --junitxml={xml_path} -q"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+            
+            if Path(xml_path).exists() and Path(xml_path).stat().st_size > 0:
+                parsed = _parse_junitxml(Path(xml_path))
+                if "error" not in parsed:
+                    result.update(parsed)
+                else:
+                    parsed_fallback = _parse_pytest_output(process.stdout + process.stderr)
+                    result.update(parsed_fallback)
+            else:
+                parsed_fallback = _parse_pytest_output(process.stdout + process.stderr)
+                result.update(parsed_fallback)
+                
+            try:
+                Path(xml_path).unlink(missing_ok=True)
+            except Exception:
+                pass
+                
+        elif framework == "unittest":
+            cmd = f"python -m unittest discover {target_str}"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+            out = process.stdout + process.stderr
+            # Unittest output is hard to parse structure-wise simply, doing basic search
+            runs = re.search(r'Ran (\d+) tests', out)
+            if runs:
+                result["total"] = int(runs.group(1))
+            failures = re.search(r'failures=(\d+)', out)
+            errors = re.search(r'errors=(\d+)', out)
+            result["failed"] = (int(failures.group(1)) if failures else 0) + (int(errors.group(1)) if errors else 0)
+            result["passed"] = result["total"] - result["failed"]
+            
+        elif framework == "npm":
+            cmd = "npm test"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+            
+        elif framework == "cargo":
+            cmd = "cargo test"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+            
+        elif framework == "go":
+            cmd = "go test ./..."
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+            
+        if framework in ("npm", "cargo", "go"):
+            # Generic fallback for non-python frameworks since detailed parsing isn't specified
+            result["success"] = process.returncode == 0
+            
+        result["output"] = _truncate(process.stdout + "\n" + process.stderr)
+        result["success"] = process.returncode == 0
+        
+    except subprocess.TimeoutExpired as e:
+        result["error"] = f"Command timed out after {timeout} seconds"
+        if e.stdout:
+            result["output"] = _truncate(e.stdout.decode(errors='replace'))
+    except Exception as e:
+        result["error"] = str(e)
+        logger.error(f"Test run failed: {e}")
+
+    result["duration_seconds"] = round(time.time() - start_time, 2)
+    return result
+
+
+@register_tool(
+    name="lint",
+    description="Run the project's linter and return structured issues",
+    risk_tier=RiskTier.SAFE,
+)
+def lint(path: Optional[str] = None) -> List[Dict[str, Any]]:
+    """Run linter and return structured issues."""
+    project_root = Path.cwd()
+    linter = _detect_linter(project_root)
+    
+    if not linter:
+        return []
+
+    target_str = path if path else "."
+    issues = []
+
+    try:
+        if linter == "ruff":
+            cmd = f"ruff check {target_str} --output-format=json"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            if process.stdout.strip():
+                try:
+                    data = json.loads(process.stdout)
+                    for item in data:
+                        issues.append({
+                            "file": item.get("filename", ""),
+                            "line": item.get("location", {}).get("row", 0),
+                            "column": item.get("location", {}).get("column", 0),
+                            "code": item.get("code", ""),
+                            "message": item.get("message", ""),
+                            "severity": "error"
+                        })
+                except json.JSONDecodeError:
+                    pass
+                    
+        elif linter == "flake8":
+            cmd = f"flake8 {target_str}"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            for line in process.stdout.splitlines():
+                match = re.match(r'(.*?):(\d+):(\d+):\s+([A-Z0-9]+)\s+(.*)', line)
+                if match:
+                    issues.append({
+                        "file": match.group(1),
+                        "line": int(match.group(2)),
+                        "column": int(match.group(3)),
+                        "code": match.group(4),
+                        "message": match.group(5),
+                        "severity": "error"
+                    })
+                    
+        elif linter == "eslint":
+            cmd = f"npx eslint {target_str} --format=json"
+            process = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            if process.stdout.strip():
+                try:
+                    data = json.loads(process.stdout)
+                    for file_item in data:
+                        for msg in file_item.get("messages", []):
+                            severity = "error" if msg.get("severity") == 2 else "warning"
+                            issues.append({
+                                "file": file_item.get("filePath", ""),
+                                "line": msg.get("line", 0),
+                                "column": msg.get("column", 0),
+                                "code": msg.get("ruleId", ""),
+                                "message": msg.get("message", ""),
+                                "severity": severity
+                            })
+                except json.JSONDecodeError:
+                    pass
+
+    except Exception as e:
+        logger.warning(f"Linter execution failed: {e}")
+        
+    return issues

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sky-dev
-Version: 0.1.9
+Version: 0.1.14
 Summary: Sky - Agentic coding assistant. Build without boundaries.
 Author-email: Aaditya A <aaditya@corover.ai>
 License: MIT

{sky_dev-0.1.9 → sky_dev-0.1.14}/sky_dev.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ sky/tools/git_tools.py
 sky/tools/registry.py
 sky/tools/search_tools.py
 sky/tools/shell_tools.py
+sky/tools/test_tools.py
 sky_dev.egg-info/PKG-INFO
 sky_dev.egg-info/SOURCES.txt
 sky_dev.egg-info/dependency_links.txt