sky-dev 0.0.5__py3-none-any.whl

sky/core/chat.py

@@ -0,0 +1,211 @@
+"""Chat mode for conversational interaction with Sky."""
+
+from typing import Optional, List, Dict, Any
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from sky.config import load_config, load_models_config
+from sky.core.router import ModelRouter
+from sky.storage import get_db
+from sky.core.fast_loop import FastLoopEngine
+from sky.core.mode_prompts import get_mode_prompt
+
+class ChatEngine:
+    """Conversational chat engine for Sky."""
+    
+    def __init__(self, config, models_config, db, router):
+        self.config = config
+        self.models_config = models_config
+        self.db = db
+        self.router = router
+        self.messages = []
+        self.session_id = db.create_session("chat", "conversation")
+        self.console = Console()
+    
+    def get_welcome_message(self) -> str:
+        """Return welcome message with capabilities."""
+        return """
+        ☁️ **Sky Chat Mode**
+
+        I'm Sky, your AI coding assistant. I can help you:
+
+        • **Answer questions** about your codebase → `/ask`
+        • **Plan features** with structured tasks → `/plan`  
+        • **Write and edit code** with approval → `/agent`
+        • **Run complex workflows** with subagents → `/workflow`
+
+        **Try asking me:**
+        - "What can you do?"
+        - "Explain the approval gate"
+        - "Help me fix a bug"
+        - "Plan a new feature"
+
+        Just type your message, and I'll guide you to the right tool!
+        """
+    
+    def suggest_command(self, user_input: str) -> Optional[str]:
+        """Suggest the right Sky command for the user's request."""
+        # Simple keyword-based routing
+        user_input_lower = user_input.lower()
+        
+        if any(word in user_input_lower for word in ["explain", "what", "how", "why", "tell me"]):
+            return f"sky ask \"{user_input}\""
+        
+        if any(word in user_input_lower for word in ["fix", "bug", "error", "issue", "problem"]):
+            return f"sky agent \"{user_input}\""
+        
+        if any(word in user_input_lower for word in ["plan", "design", "architecture", "feature"]):
+            return f"sky plan \"{user_input}\""
+        
+        if any(word in user_input_lower for word in ["build", "add", "implement", "create", "workflow"]):
+            return f"sky workflow \"{user_input}\""
+        
+        return None
+    
+    def run(self, initial_prompt: Optional[str] = None):
+        """Run the chat loop."""
+        self.console.print(Panel(
+            Markdown(self.get_welcome_message()),
+            title="☁️ Sky Chat",
+            border_style="cyan"
+        ))
+        
+        if initial_prompt:
+            self._process_user_message(initial_prompt)
+        
+        while True:
+            user_input = Prompt.ask("\n[bold cyan]You[/bold cyan]")
+            
+            if user_input.lower() in ["exit", "quit", "bye"]:
+                self.console.print("[dim]Goodbye! 👋[/dim]")
+                break
+            
+            if user_input.startswith("/"):
+                self._handle_command(user_input)
+                continue
+            
+            self._process_user_message(user_input)
+    
+    def _process_user_message(self, user_input: str):
+        """Process user message and generate response."""
+        
+        # Check for identity questions
+        if any(phrase in user_input.lower() for phrase in ["who built", "who created", "who developed", "who made you"]):
+            self._respond_with_creator_info()
+            return
+            
+        # Check if we should suggest a command
+        suggested = self.suggest_command(user_input)
+        
+        if suggested:
+            self.console.print(f"\n[dim]💡 I can help you with that! Try:[/dim]")
+            self.console.print(f"  [bold cyan]{suggested}[/bold cyan]")
+            
+            if Confirm.ask("\n[dim]Would you like me to run this for you?[/dim]", default=False):
+                self.console.print(f"\n[dim]⏳ Running: {suggested}[/dim]")
+                # Execute the command
+                import subprocess
+                import shlex
+                try:
+                    parts = shlex.split(suggested)
+                except ValueError:
+                    parts = suggested.split()
+                    
+                if sys.platform == "win32":
+                    cmd = ["python", "-m", "sky.cli"] + parts[1:]
+                else:
+                    cmd = parts
+                subprocess.run(cmd, check=False)
+                return
+        
+        # Fallback: use chat model for conversation
+        import asyncio
+        asyncio.run(self._get_chat_response(user_input))
+
+    def _respond_with_creator_info(self):
+        """Respond with creator information."""
+        response = """
+        I was built by **Aaditya A** 👨‍💻
+
+        - **Role:** AI/ML Intern at CoRover.ai
+        - **About:** MCA - AI/ML Final year student at JAIN UNIVERSITY, BANGALORE
+        
+        Sky is a local, CLI-based, agentic software development assistant that helps developers plan, write, test, and self-correct code.
+        """
+        self.console.print(f"\n[bold cyan]Sky[/bold cyan]")
+        self.console.print(Markdown(response))
+        self.messages.append({"role": "user", "content": "Who built you?"})
+        self.messages.append({"role": "assistant", "content": response})
+    
+    async def _get_chat_response(self, user_input: str):
+        """Get response from chat model."""
+        if not any(m.get("role") == "system" for m in self.messages):
+            from sky.core.mode_prompts import get_mode_prompt
+            self.messages.insert(0, {"role": "system", "content": get_mode_prompt("chat")})
+            
+        self.messages.append({"role": "user", "content": user_input})
+        
+        try:
+            with self.console.status("[bold cyan]Thinking...", spinner="dots"):
+                response, was_fallback, model_used = await self.router.route(
+                    "general",
+                    self.messages,
+                    expected_tool_calls=0
+                )
+            
+            content = response.get("content", "")
+            
+            self.console.print(f"\n[bold cyan]Sky[/bold cyan]")
+            self.console.print(Markdown(content))
+            
+            self.messages.append({"role": "assistant", "content": content})
+            
+        except Exception as e:
+            self.console.print(f"[red]Error: {e}[/red]")
+    
+    def _handle_command(self, user_input: str):
+        """Handle slash commands."""
+        import sys
+        import shlex
+        try:
+            parts = shlex.split(user_input)
+        except ValueError:
+            parts = user_input.split()
+            
+        cmd = parts[0].lower()
+        args = parts[1:]
+        
+        if cmd == "/ask":
+            self.console.print("[dim]Switching to /ask mode...[/dim]")
+            import subprocess
+            if sys.platform == "win32":
+                subprocess.run(["python", "-m", "sky.cli", "ask"] + args, check=False)
+            else:
+                subprocess.run(["sky", "ask"] + args, check=False)
+        elif cmd == "/agent":
+            self.console.print("[dim]Switching to /agent mode...[/dim]")
+            import subprocess
+            if sys.platform == "win32":
+                subprocess.run(["python", "-m", "sky.cli", "agent"] + args, check=False)
+            else:
+                subprocess.run(["sky", "agent"] + args, check=False)
+        elif cmd == "/workflow":
+            self.console.print("[dim]Switching to /workflow mode...[/dim]")
+            import subprocess
+            if sys.platform == "win32":
+                subprocess.run(["python", "-m", "sky.cli", "workflow"] + args, check=False)
+            else:
+                subprocess.run(["sky", "workflow"] + args, check=False)
+        elif cmd == "/plan":
+            self.console.print("[dim]Switching to /plan mode...[/dim]")
+            import subprocess
+            if sys.platform == "win32":
+                subprocess.run(["python", "-m", "sky.cli", "plan"] + args, check=False)
+            else:
+                subprocess.run(["sky", "plan"] + args, check=False)
+        else:
+            self.console.print(f"[red]Unknown command: {cmd}[/red]")
+
+import sys

sky/core/fast_loop.py

@@ -0,0 +1,330 @@
+"""Fast Loop Engine for iterative agent execution."""
+
+import asyncio
+import json
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from sky.config import DexProjectConfig
+from sky.core.approval import ApprovalGate
+from sky.core.mode_prompts import get_mode_prompt
+from sky.core.router import ModelRouter
+from sky.storage import DatabaseManager
+from sky.tools.registry import RiskTier, get_tool, get_tool_schemas
+from sky.security import get_security_guardrails
+
+
+class FastLoopEngine:
+    """Core engine for running the agent loop."""
+
+    def __init__(self, config: DexProjectConfig, db: DatabaseManager, router: ModelRouter, session_id: str, approval_gate: Optional[ApprovalGate] = None, indexer: Optional[Any] = None):
+        self.config = config
+        self.db = db
+        self.router = router
+        self.approval_gate = approval_gate
+        self.session_id = session_id
+        self.indexer = indexer
+        
+        from rich.console import Console
+        if self.approval_gate is None:
+            Console().print("[bold yellow]WARNING: FastLoopEngine initialized without approval_gate. Destructive tools will be blocked.[/bold yellow]")
+        else:
+            if self.config.verbose:
+                Console().print("[dim]approval_gate passed to FastLoopEngine[/dim]")
+
+    def _get_available_tools(self, mode: str, tools_filter: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+        """Filter tools based on mode and specific filter list."""
+        all_schemas = get_tool_schemas()
+        
+        if mode == "ask":
+            safe_schemas = []
+            for schema in all_schemas:
+                tool_def = get_tool(schema["function"]["name"])
+                if tool_def and tool_def.risk_tier == RiskTier.SAFE:
+                    safe_schemas.append(schema)
+            all_schemas = safe_schemas
+        elif mode == "agent":
+            # Explicitly keep ALL tools for agent mode
+            pass
+            
+        if tools_filter:
+            all_schemas = [s for s in all_schemas if s["function"]["name"] in tools_filter]
+            
+        return all_schemas
+
+    async def _execute_safe_tool(self, tool_call_id: str, tool_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a single safe tool asynchronously."""
+        tool_def = get_tool(tool_name)
+        if not tool_def:
+            result_str = f"Error: Tool {tool_name} not found."
+        else:
+            try:
+                result = tool_def.func(**args)
+                result_str = json.dumps(result) if not isinstance(result, str) else result
+            except Exception as e:
+                result_str = f"Error: {e}"
+                
+        self.db.log_tool_call(self.session_id, tool_name, args, "safe", "auto_approved", result=result_str)
+        
+        return {
+            "tool_call_id": tool_call_id,
+            "role": "tool",
+            "name": tool_name,
+            "content": result_str,
+        }
+
+    async def _execute_destructive_tool(self, tool_call_id: str, tool_name: str, args: Dict[str, Any], mode: str) -> Dict[str, Any]:
+        """Execute a destructive tool sequentially with approval gate."""
+        from rich.console import Console
+        console = Console()
+        if self.config.verbose:
+            console.print(f"[dim]_execute_destructive_tool called for {tool_name}[/dim]")
+            
+        tool_def = get_tool(tool_name)
+        if not tool_def:
+            result_str = f"Error: Tool {tool_name} not found."
+            self.db.log_tool_call(self.session_id, tool_name, args, "destructive", "rejected", result=result_str)
+            return {
+                "tool_call_id": tool_call_id,
+                "role": "tool",
+                "name": tool_name,
+                "content": result_str,
+            }
+            
+        if self.approval_gate is None:
+            console.print(f"[bold red]CRITICAL: approval_gate is None! Rejecting {tool_name}[/bold red]")
+            return {
+                "tool_call_id": tool_call_id,
+                "role": "tool",
+                "name": tool_name,
+                "content": f"Execution rejected: approval_gate is not initialized.",
+            }
+            
+        approved, reason, final_args = self.approval_gate.process(tool_name, args)
+        
+        if self.config.verbose:
+            console.print(f"[dim]approval_gate.process() returned decision: approved={approved}, reason={reason}[/dim]")
+            
+        if not approved:
+            result_str = f"Execution rejected by user: {reason}"
+        else:
+            execute_args = final_args or args
+            try:
+                result = tool_def.func(**execute_args)
+                result_str = json.dumps(result) if not isinstance(result, str) else result
+            except Exception as e:
+                result_str = f"Error: {e}"
+                
+        return {
+            "tool_call_id": tool_call_id,
+            "role": "tool",
+            "name": tool_name,
+            "content": result_str,
+        }
+
+    def _validate_tool_calls(self, tool_calls: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+        """Validate that tool calls are well-formed JSON. Returns (valid_calls, error_results)."""
+        valid_calls = []
+        error_results = []
+        for tc in tool_calls:
+            try:
+                if not isinstance(tc, dict):
+                    raise ValueError("Tool call is not a dictionary")
+                if "function" not in tc or "name" not in tc["function"]:
+                    raise ValueError("Missing 'function' or 'name' in tool call")
+                    
+                tool_name = tc["function"]["name"]
+                args_raw = tc["function"].get("arguments", "{}")
+                
+                if isinstance(args_raw, str):
+                    try:
+                        args_dict = json.loads(args_raw)
+                    except json.JSONDecodeError as e:
+                        raise ValueError(f"Arguments are not valid JSON: {e}")
+                else:
+                    args_dict = args_raw
+
+                if getattr(self.config, "security_enabled", True):
+                    guardrails = get_security_guardrails()
+                    guardrails.strict_mode = getattr(self.config, "security_strict_mode", True)
+                    is_valid, err_msg = guardrails.validate_tool_call(tool_name, args_dict)
+                    if not is_valid:
+                        error_results.append({
+                            "tool_call_id": tc.get("id", "unknown"),
+                            "role": "tool",
+                            "name": tool_name,
+                            "content": f"Security Guardrail Blocked: {err_msg}"
+                        })
+                        continue
+
+                valid_calls.append(tc)
+            except Exception as e:
+                from rich.console import Console
+                Console().print(f"[bold red]Skipping invalid tool call: {e}[/bold red]")
+                error_results.append({
+                    "tool_call_id": tc.get("id", "unknown") if isinstance(tc, dict) else "unknown",
+                    "role": "tool",
+                    "name": tc.get("function", {}).get("name", "unknown") if isinstance(tc, dict) and "function" in tc else "unknown",
+                    "content": f"System Error: Invalid tool call format - {e}. You MUST use native JSON tool calls. DO NOT output XML."
+                })
+        return valid_calls, error_results
+
+    async def _execute_tool_calls(self, tool_calls: List[Dict[str, Any]], mode: str) -> List[Dict[str, Any]]:
+        """Execute a list of tool calls, handling risk tiers appropriately."""
+        results = []
+        safe_tasks = []
+        
+        valid_calls, error_results = self._validate_tool_calls(tool_calls)
+        results.extend(error_results)
+        
+        for tc in valid_calls:
+            tool_name = tc["function"]["name"]
+            try:
+                args = json.loads(tc["function"]["arguments"])
+            except Exception:
+                args = {}
+                
+            tool_def = get_tool(tool_name)
+            
+            if tool_def and tool_def.risk_tier == RiskTier.SAFE:
+                safe_tasks.append(self._execute_safe_tool(tc["id"], tool_name, args))
+            else:
+                if safe_tasks:
+                    safe_results = await asyncio.gather(*safe_tasks)
+                    results.extend(safe_results)
+                    safe_tasks = []
+                    
+                res = await self._execute_destructive_tool(tc["id"], tool_name, args, mode)
+                results.append(res)
+                
+        if safe_tasks:
+            safe_results = await asyncio.gather(*safe_tasks)
+            results.extend(safe_results)
+            
+        return results
+
+    def _get_relevant_context(self, query: str) -> str:
+        """Retrieve relevant context for the query if memory is enabled."""
+        if not self.indexer or not getattr(self.config, "memory_enabled", False):
+            return ""
+            
+        from rich.console import Console
+        if self.config.verbose:
+            Console().print(f"[dim]Retrieving context for query...[/dim]")
+            
+        context = self.indexer.get_context(query, top_k=getattr(self.config, "memory_top_k", 5))
+        if not context:
+            return ""
+            
+        return context
+
+    async def run(
+        self, 
+        messages: List[Dict[str, Any]], 
+        mode: str, 
+        system_prompt: Optional[str] = None, 
+        max_turns: Optional[int] = None, 
+        tools_filter: Optional[List[str]] = None,
+        inject_context: bool = False
+    ) -> AsyncIterator[Dict[str, Any]]:
+        """Run the main agent loop streaming events."""
+        turn_limit = max_turns or self.config.max_turn_limit
+        if getattr(self.config, "security_enabled", True):
+            from sky.security.prompts import get_system_prompt_with_guardrails, get_hardened_system_prompt
+            if system_prompt:
+                prompt = get_hardened_system_prompt(system_prompt)
+            else:
+                prompt = get_system_prompt_with_guardrails(mode)
+        else:
+            prompt = system_prompt or get_mode_prompt(mode)
+        
+        # Get context from first user message
+        user_query = ""
+        for msg in messages:
+            if msg.get("role") == "user":
+                user_query = str(msg.get("content", ""))
+                break
+                
+        from sky.core.mode_prompts import format_context_prompt
+        if inject_context and self.indexer and getattr(self.config, "memory_enabled", False):
+            context = self._get_relevant_context(user_query)
+            prompt = format_context_prompt(prompt, context)
+        else:
+            prompt = format_context_prompt(prompt, "")
+            
+        if getattr(self.config, "security_enabled", True):
+            from sky.security.sanitize import validate_context_size
+            if not validate_context_size(messages, max_tokens=getattr(self.config, "security_max_input_length", 10000)):
+                yield {"type": "error", "message": "Context size exceeds limit. Please start a new session."}
+                return
+            
+        if not messages or messages[0].get("role") != "system":
+            messages.insert(0, {"role": "system", "content": prompt})
+        else:
+            messages[0]["content"] = prompt
+            
+        tools = self._get_available_tools(mode, tools_filter)
+        role = "fast_loop" if mode == "agent" else "routing"
+        
+        if self.config.verbose:
+            from rich.console import Console
+            Console().print(f"[dim]Available tools for {mode}: {[t['function']['name'] for t in tools]}[/dim]")
+        
+        for turn in range(turn_limit):
+            yield {"type": "turn_start", "turn": turn + 1}
+            
+            expected = 1
+            
+            try:
+                response_msg, was_fallback, model_used = await self.router.route(
+                    role=role,
+                    messages=messages,
+                    tools=tools if tools else None,
+                    expected_tool_calls=expected if tools else None
+                )
+            except Exception as e:
+                error_str = str(e)
+                if "tool call validation failed" in error_str or "invalid_request_error" in error_str or "400" in error_str:
+                    from rich.console import Console
+                    Console().print(f"[yellow]Model tool validation failed. Feeding error back to model...[/yellow]")
+                    messages.append({
+                        "role": "user",
+                        "content": f"System Error: Your last response triggered an API validation error: {error_str}\n\nYou MUST use native JSON tool calls. DO NOT output XML pseudo-tags like <tool_call>. Only call tools that are explicitly provided in the schema."
+                    })
+                    continue
+                else:
+                    raise e
+            
+            messages.append(response_msg)
+            
+            yield {
+                "type": "model_response", 
+                "message": response_msg, 
+                "was_fallback": was_fallback, 
+                "model": model_used
+            }
+            
+            if "tool_calls" in response_msg and response_msg["tool_calls"]:
+                for tc in response_msg["tool_calls"]:
+                    if "function" in tc:
+                        yield {
+                            "type": "tool_call",
+                            "tool_name": tc["function"].get("name", "unknown"),
+                            "args": tc["function"].get("arguments", "{}")
+                        }
+                
+                tool_results = await self._execute_tool_calls(response_msg["tool_calls"], mode)
+                messages.extend(tool_results)
+                
+                for res in tool_results:
+                    yield {
+                        "type": "tool_result",
+                        "tool_name": res.get("name", "unknown"),
+                        "result": res.get("content", "")
+                    }
+                
+                yield {"type": "tool_results", "results": tool_results}
+            else:
+                yield {"type": "final_answer", "content": response_msg.get("content", "")}
+                break
+        else:
+            yield {"type": "error", "content": f"Turn limit of {turn_limit} exceeded."}

sky/core/mode_prompts.py

@@ -0,0 +1,106 @@
+"""System prompts for different SKY operational modes."""
+
+ASK_SYSTEM_PROMPT = """You are SKY, a local AI coding assistant running directly on the user's machine. 
+Your role is to answer questions, explain code, and read files.
+You are in READ-ONLY mode. You may use SAFE tools to gather information.
+Do NOT attempt to modify any files or run destructive commands.
+Do NOT introduce yourself as ChatGPT or an AI from OpenAI. You are SKY.
+Provide clear, concise, and helpful answers.
+
+{CONTEXT_PLACEHOLDER}"""
+
+AGENT_SYSTEM_PROMPT = """You are SKY, an autonomous AI software engineer running locally on the user's machine.
+Your role is to execute full software development tasks by using the provided tools.
+Do NOT introduce yourself as ChatGPT or an AI from OpenAI. You are SKY.
+You MUST use the native JSON tool calling mechanism provided by the system.
+DO NOT output pseudo-tags like <tool_call>, <function=...>, <parameter=...>.
+DO NOT write XML or HTML for tool calls. DO NOT write code for the user to run manually; use your tools (like bash or edit_file) to execute it directly.
+
+Example of correct internal native JSON tool call format:
+{
+  "name": "edit_file",
+  "arguments": {
+    "path": "file.py",
+    "diff": "..."
+  }
+}
+
+You have access to all tools, including DESTRUCTIVE ones (edit files, run tests, run shell commands).
+Work methodically:
+1. Gather information (read files, run grep, git status)
+2. Make changes (edit files)
+3. Verify your changes (run tests, lint)
+4. Self-correct if errors occur.
+
+If you need to make multiple tool calls (e.g. read multiple files), execute them in parallel when possible.
+Provide a final textual answer only when the task is complete.
+
+{CONTEXT_PLACEHOLDER}"""
+
+PLAN_SYSTEM_PROMPT = """You are SKY in PLANNING mode.
+Your role is to analyze a request and produce a structured execution plan.
+Do NOT execute the plan. 
+First, research the codebase using SAFE tools.
+Once you have enough context, output a structured JSON plan."""
+
+CHAT_SYSTEM_PROMPT = """You are Sky, an agentic coding assistant.
+
+Identity:
+- Purpose: Help developers plan, write, test, and understand code
+
+Capabilities:
+- Answer questions about codebases
+- Plan features with structured tasks
+- Write and edit code (with human approval)
+- Run complex workflows with subagents
+- Search code semantically
+
+Personality:
+- Friendly, helpful, and concise
+- Focus on coding assistance
+- Guide users to Sky's features
+- Be transparent about capabilities and limitations
+
+When users ask about general topics, politely redirect to coding assistance.
+
+You are NOT ChatGPT, Claude, or any other AI. You are Sky.
+"""
+
+PLAN_WRITE_PROMPT = """{
+  "type": "object",
+  "properties": {
+    "goal": {"type": "string"},
+    "steps": {
+      "type": "array",
+      "items": {"type": "string"}
+    }
+  },
+  "required": ["goal", "steps"]
+}"""
+
+def get_mode_prompt(mode: str) -> str:
+    """Return the appropriate system prompt for the given mode."""
+    mode = mode.lower()
+    if mode == "ask":
+        return ASK_SYSTEM_PROMPT
+    elif mode == "agent":
+        return AGENT_SYSTEM_PROMPT
+    elif mode == "plan":
+        return PLAN_SYSTEM_PROMPT
+    elif mode == "chat":
+        return CHAT_SYSTEM_PROMPT
+    else:
+        return AGENT_SYSTEM_PROMPT
+
+def format_context_prompt(prompt: str, context: str) -> str:
+    """Format the system prompt by replacing the context placeholder.
+    
+    If context is provided, it replaces the placeholder with the repository context section.
+    Otherwise, it strips out the placeholder.
+    """
+    if context:
+        context_section = f"## Repository Context\n\nThe system has retrieved relevant code from your repository to help answer your question.\nThis context is injected below. Use it to inform your responses.\n\n{context}"
+        return prompt.replace("{CONTEXT_PLACEHOLDER}", context_section)
+    else:
+        return prompt.replace("{CONTEXT_PLACEHOLDER}", "").strip()
+