shellmate-cli 3.0.0__py3-none-any.whl

shellmate/agents/query.py

@@ -0,0 +1,415 @@
+"""
+QueryAgent: Processes user queries about command analysis.
+
+Handles queries like [?why], [?what-if], [?alternatives], [?history], [?impact]
+and provides context-aware responses based on AnalysisState.
+"""
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from shellmate.agents.base import Agent, AgentRequest, AgentResponse
+from shellmate.orchestration.state import AnalysisState
+
+
+class QueryAgent(Agent):
+    """Processes user queries about command analysis."""
+
+    def __init__(self):
+        super().__init__(name="query")
+        self.query_handlers = {
+            "why": self._answer_why,
+            "what-if": self._answer_what_if,
+            "what if": self._answer_what_if,
+            "alternatives": self._answer_alternatives,
+            "history": self._answer_history,
+            "impact": self._answer_impact,
+            "did i": self._answer_did_i,
+        }
+
+    async def initialize(self) -> None:
+        """Initialize the agent."""
+        pass
+
+    async def shutdown(self) -> None:
+        """Shutdown the agent."""
+        pass
+
+    async def process(self, request: AgentRequest) -> AgentResponse:
+        """Process agent requests by dispatching to appropriate methods."""
+        start_time = time.time()
+
+        try:
+            if request.command == "process_queries":
+                queries = request.data.get("queries", [])
+                state = request.data.get("state", {})
+                responses = await self.process_queries(queries, state)
+                latency = (time.time() - start_time) * 1000
+                return AgentResponse(
+                    request.request_id,
+                    self.name,
+                    status="ok",
+                    data={"responses": responses},
+                    latency_ms=latency,
+                )
+            else:
+                return AgentResponse(
+                    request.request_id,
+                    self.name,
+                    status="error",
+                    error=f"Unknown command: {request.command}",
+                )
+        except Exception as e:
+            latency = (time.time() - start_time) * 1000
+            return AgentResponse(
+                request.request_id,
+                self.name,
+                status="error",
+                error=str(e),
+                latency_ms=latency,
+            )
+
+    async def process_queries(
+        self, queries: List[str], state: AnalysisState
+    ) -> Dict[str, str]:
+        """
+        Process all user queries and return responses with caching.
+
+        Args:
+            queries: List of query strings
+            state: Current AnalysisState with all context
+
+        Returns:
+            Dictionary mapping queries to responses
+        """
+        responses = {}
+        cache = self._load_cache()
+        command = state.get("command", "")
+
+        for query in queries:
+            # Check cache first
+            cache_key = f"{command}::{query}"
+            if cache_key in cache:
+                responses[query] = cache[cache_key]
+                continue
+
+            # Process query if not cached
+            query_lower = query.lower().strip()
+
+            # Match query to handler
+            handler = None
+            for key, func in self.query_handlers.items():
+                if query_lower.startswith(key) or key in query_lower:
+                    handler = func
+                    break
+
+            if handler:
+                try:
+                    response = await handler(query, state)
+                    responses[query] = response
+                    # Cache the response
+                    cache[cache_key] = response
+                except Exception as e:
+                    responses[query] = f"Unable to answer: {str(e)}"
+            else:
+                response = (
+                    "I don't understand this question. "
+                    "Try: [?why], [?what-if], [?alternatives], [?history], [?impact]"
+                )
+                responses[query] = response
+                cache[cache_key] = response
+
+        # Save updated cache
+        self._save_cache(cache)
+        return responses
+
+    async def _answer_why(self, query: str, state: AnalysisState) -> str:
+        """Explain why command is risky."""
+        # Get risk level (correction C-1: key is "risk", not "risk_level")
+        risk_analysis = state.get("risk_analysis") or {}
+        risk_level = risk_analysis.get("risk", "UNKNOWN")
+        env_context = state.get("environment_context", {})
+        chain_patterns = state.get("chain_patterns", {})
+        risk_factors = state.get("risk_factors", {})
+
+        reasons = [f"This command is {risk_level} risk because:"]
+
+        # Environment factors
+        env_type = env_context.get("type", "unknown")
+        if env_type == "production":
+            reasons.append("• Running in production environment")
+        elif env_type == "staging":
+            reasons.append("• Running in staging environment")
+
+        time_ctx = env_context.get("time", {})
+        if time_ctx.get("is_business_hours"):
+            hour = time_ctx.get("hour", 0)
+            reasons.append(f"• Business hours ({hour}:00)")
+
+        blast = env_context.get("blast_radius", {})
+        if blast.get("is_multi_user"):
+            user_count = blast.get("active_users", 0)
+            reasons.append(f"• {user_count} other users active")
+
+        services = blast.get("critical_services", [])
+        if services:
+            reasons.append(f"• Critical services running: {', '.join(services)}")
+
+        resources = env_context.get("resources", {})
+        if resources.get("disk_low"):
+            reasons.append(
+                f"• Low disk space ({resources.get('disk_free_percent', 0)}% free)"
+            )
+        if resources.get("memory_high"):
+            reasons.append(
+                f"• High memory usage ({resources.get('memory_used_percent', 0)}%)"
+            )
+
+        # Chain factors
+        for pattern in chain_patterns.get("broken", []):
+            reasons.append(f"• Workflow broken: {pattern['description']}")
+
+        for pattern in chain_patterns.get("dangerous_escalations", []):
+            reasons.append(f"• Dangerous escalation: {pattern['description']}")
+
+        # Risk breakdown
+        if risk_factors:
+            reasons.append("")
+            reasons.append("Risk Breakdown:")
+            for factor, weight in risk_factors.items():
+                if weight > 0:
+                    percentage = int(weight * 100)
+                    reasons.append(f"  {factor.title()}: {percentage}%")
+
+        # Add primary reason from analysis
+        if risk_analysis.get("reason"):
+            reasons.append("")
+            reasons.append(f"Primary reason: {risk_analysis['reason']}")
+
+        return "\n".join(reasons)
+
+    async def _answer_what_if(self, query: str, state: AnalysisState) -> str:
+        """Answer '[?what-if]' using consequence_preview (hypothetical outcome)."""
+        command = state.get("command") or "this command"
+        consequence = state.get("consequence_preview") or {}
+        risk_analysis = state.get("risk_analysis") or {}
+        env_context = state.get("environment_context") or {}
+        remediation = state.get("remediation") or {}
+
+        what_happens = consequence.get("what_happens") or risk_analysis.get("reason")
+        scope = consequence.get("scope")
+        reversible = consequence.get("reversible")
+        affected = consequence.get("affected_count")
+        severity = consequence.get("severity") or risk_analysis.get("risk")
+        suggested = consequence.get("suggested_fix")
+
+        if not suggested:
+            alternatives = remediation.get("alternatives") or []
+            if alternatives:
+                suggested = alternatives[0]
+
+        lines = [f"If you run `{command}`:"]
+
+        if what_happens:
+            lines.append(f"• What happens: {what_happens}")
+        else:
+            lines.append("• What happens: Outcome is unclear from available analysis")
+
+        if scope:
+            lines.append(f"• Scope: {scope}")
+
+        env_type = env_context.get("type")
+        if env_type:
+            lines.append(f"• Environment: {env_type}")
+
+        if reversible is not None:
+            lines.append(f"• Reversible: {'yes' if reversible else 'no'}")
+
+        if affected is not None:
+            lines.append(f"• Affected: {affected}")
+
+        blast = env_context.get("blast_radius") or {}
+        if blast.get("is_multi_user"):
+            users = blast.get("active_users", 0)
+            lines.append(f"• Active users impacted: {users}")
+
+        if severity:
+            lines.append(f"• Severity: {severity}")
+
+        if suggested:
+            lines.append(f"• Safer form: {suggested}")
+
+        return "\n".join(lines)
+
+    async def _answer_alternatives(self, query: str, state: AnalysisState) -> str:
+        """Suggest safer alternatives."""
+        remediation = state.get("remediation", {})
+        alternatives = remediation.get("alternatives", [])
+
+        if not alternatives:
+            return "No safer alternatives identified."
+
+        lines = ["Safer alternatives:"]
+        for i, alt in enumerate(alternatives[:5], 1):
+            lines.append(f"{i}. {alt}")
+
+        return "\n".join(lines)
+
+    async def _answer_history(self, query: str, state: AnalysisState) -> str:
+        """Query command history."""
+        command = state.get("command", "")
+        command_chain = state.get("command_chain", [])
+
+        # Check if command was run before
+        matching = [c for c in command_chain if c.get("command") == command]
+
+        if not matching:
+            return "You haven't run this exact command in this session."
+
+        last_run = matching[-1]
+        timestamp = last_run.get("timestamp", "unknown")
+        exit_code = last_run.get("exit_code", "unknown")
+        risk = last_run.get("risk", "unknown")
+
+        return (
+            f"Last run: {timestamp}\n"
+            f"Exit code: {exit_code}\n"
+            f"Risk level: {risk}"
+        )
+
+    async def _answer_impact(self, query: str, state: AnalysisState) -> str:
+        """Estimate blast radius and impact."""
+        env_context = state.get("environment_context", {})
+        blast = env_context.get("blast_radius", {})
+        resources = env_context.get("resources", {})
+
+        impact_lines = ["This command will affect:"]
+
+        env_type = env_context.get("type", "unknown")
+        impact_lines.append(f"• Environment: {env_type}")
+
+        if blast.get("is_multi_user"):
+            user_count = blast.get("active_users", 0)
+            impact_lines.append(f"• {user_count} active users on this system")
+
+        services = blast.get("critical_services", [])
+        if services:
+            impact_lines.append(f"• Critical services: {', '.join(services)}")
+
+        if resources.get("disk_low"):
+            impact_lines.append(
+                f"• WARNING: Low disk space ({resources.get('disk_free_percent', 0)}% free)"
+            )
+
+        if resources.get("memory_high"):
+            impact_lines.append(
+                f"• WARNING: High memory usage ({resources.get('memory_used_percent', 0)}%)"
+            )
+
+        if resources.get("cpu_high"):
+            impact_lines.append(
+                f"• WARNING: High CPU load ({resources.get('cpu_load_percent', 0)}%)"
+            )
+
+        if len(impact_lines) == 1:
+            impact_lines.append("• No significant impact factors detected")
+
+        return "\n".join(impact_lines)
+
+    async def _answer_did_i(self, query: str, state: AnalysisState) -> str:
+        """Answer 'did I...' questions about command history."""
+        command_chain = state.get("command_chain", [])
+
+        if not command_chain:
+            return "No command history available for this session."
+
+        # Try to extract what they're asking about
+        query_lower = query.lower()
+        search_terms = []
+
+        # Extract keywords after "did i"
+        if "did i" in query_lower:
+            after_did_i = query_lower.split("did i", 1)[1].strip()
+            search_terms = after_did_i.split()
+
+        if not search_terms:
+            return "I couldn't understand what you're asking about."
+
+        # Search history for matching commands
+        matching = []
+        for entry in command_chain:
+            cmd = entry.get("command", "").lower()
+            if any(term in cmd for term in search_terms):
+                matching.append(entry)
+
+        if not matching:
+            return f"No, you haven't run commands matching: {' '.join(search_terms)}"
+
+        # Return recent matches
+        lines = [f"Yes, you ran {len(matching)} matching command(s):"]
+        for entry in matching[-5:]:  # Last 5 matches
+            timestamp = entry.get("timestamp", "unknown")
+            command = entry.get("command", "unknown")
+            lines.append(f"• {timestamp}: {command}")
+
+        return "\n".join(lines)
+
+
+    def _load_cache(self) -> dict:
+        """Load query cache from session storage.
+        
+        Returns:
+            dict: Cached query responses (command::query -> response)
+        """
+        try:
+            from shellmate.daemon.session import get_query_cache_file
+            cache_file = get_query_cache_file()
+
+            if not cache_file.exists():
+                return {}
+
+            with open(cache_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            # Gracefully handle any cache loading errors
+            return {}
+
+    def _save_cache(self, cache: dict) -> None:
+        """Save query cache to session storage.
+        
+        Args:
+            cache: Dictionary of cached responses to save
+        """
+        try:
+            from shellmate.daemon.session import get_query_cache_file
+            cache_file = get_query_cache_file()
+
+            # Ensure parent directory exists
+            cache_file.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(cache_file, "w", encoding="utf-8") as f:
+                json.dump(cache, f, indent=2)
+
+            # Set restrictive permissions on non-Windows
+            import sys
+            if sys.platform != "win32":
+                import os
+                os.chmod(cache_file, 0o600)
+        except Exception:
+            # Silently ignore cache save errors to not break query processing
+            pass
+
+
+# Singleton instance
+_query_agent: Optional[QueryAgent] = None
+
+
+def get_query_agent() -> QueryAgent:
+    """Get the singleton QueryAgent instance."""
+    global _query_agent
+    if _query_agent is None:
+        _query_agent = QueryAgent()
+    return _query_agent

shellmate/agents/repomix_backend.py

@@ -0,0 +1,171 @@
+import asyncio
+import logging
+import os
+import re
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from shellmate.config.secrets import redact_secrets
+from shellmate.daemon.session import get_session_dir_path
+
+logger = logging.getLogger("shellmate.repomix")
+
+MAX_SNIPPET_LENGTH = 200
+MAX_MATCHES = 10
+
+
+class RepomixBackend:
+    def __init__(self):
+        self._pack_path: Optional[Path] = None
+        self._pack_content: Optional[str] = None
+        self._ready = False
+
+    async def initialize(self) -> None:
+        try:
+            session_dir = get_session_dir_path()
+            session_dir.mkdir(parents=True, exist_ok=True)
+            self._pack_path = session_dir / "repomix_pack.txt"
+            await self._generate_pack()
+            self._ready = True
+            logger.info(f"Repomix pack generated: {self._pack_path}")
+        except Exception as e:
+            logger.warning(f"Failed to initialize repomix backend: {e}")
+            self._ready = False
+
+    async def _generate_pack(self) -> None:
+        project_root = Path.cwd()
+        lines = []
+        eligible_extensions = {
+            ".py", ".js", ".ts", ".jsx", ".tsx", ".rs", ".go", ".java", ".rb",
+            ".php", ".c", ".cpp", ".h", ".hpp", ".cs", ".swift", ".kt", ".scala",
+            ".sh", ".bash", ".zsh", ".ps1", ".bat", ".cmd",
+            ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf",
+            ".md", ".rst", ".txt", ".html", ".css", ".scss", ".less",
+            ".xml", ".svg", ".dockerfile",
+            ".env", ".env.example",
+            ".gitignore", ".gitattributes",
+            ".editorconfig", ".prettierrc", ".eslintrc",
+        }
+        exclude_dirs = {
+            ".git", "__pycache__", "node_modules", "venv", ".venv", "env",
+            ".env", "virtualenv", ".tox", ".nox",
+            ".mypy_cache", ".pytest_cache", ".ruff_cache",
+            "target", "build", "dist", ".next", ".nuxt",
+            ".cache", ".npm", ".yarn", ".pnpm-store",
+            "vendor", ".bundle", "deps", "third_party",
+            ".idea", ".vscode", ".vs",
+        }
+        exclude_files = {
+            "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+            ".DS_Store", "Thumbs.db",
+        }
+
+        for root, dirs, files in os.walk(project_root, topdown=True):
+            rel_root = Path(root).relative_to(project_root)
+            dirs[:] = [d for d in dirs if d not in exclude_dirs]
+            for f in files:
+                if f in exclude_files:
+                    continue
+                file_path = Path(root) / f
+                ext = file_path.suffix.lower()
+                if ext not in eligible_extensions and f.lower() not in ("makefile", "dockerfile", "procfile"):
+                    continue
+                try:
+                    rel_path = file_path.relative_to(project_root)
+                    content = file_path.read_text(encoding="utf-8", errors="replace")
+                    content = redact_secrets(content)
+                    lines.append(f"## {rel_path}")
+                    lines.append("```" + (ext.lstrip(".") if ext else "text"))
+                    lines.append(content)
+                    lines.append("```")
+                    lines.append("")
+                except (OSError, UnicodeDecodeError):
+                    continue
+
+        content = "\n".join(lines)
+        if self._pack_path:
+            self._pack_path.write_text(content, encoding="utf-8")
+        self._pack_content = content
+
+    async def search(self, query: str) -> Dict[str, Any]:
+        if not self._ready or not self._pack_content:
+            return {"matches": []}
+
+        start = time.monotonic()
+        tokens = self._tokenize(query)
+        if not tokens:
+            return {"matches": []}
+
+        current_file = None
+        file_scores: Dict[str, float] = {}
+        file_snippets: Dict[str, str] = {}
+        file_sizes: Dict[str, int] = {}
+
+        lines = self._pack_content.split("\n")
+        for line in lines:
+            if line.startswith("## "):
+                current_file = line[3:].strip()
+                continue
+            if current_file:
+                for token in tokens:
+                    if token in line.lower():
+                        file_scores[current_file] = file_scores.get(current_file, 0) + 1
+                        if current_file not in file_snippets and line.strip():
+                            snippet = line.strip()
+                            if len(snippet) > MAX_SNIPPET_LENGTH:
+                                snippet = snippet[:MAX_SNIPPET_LENGTH] + "..."
+                            file_snippets[current_file] = snippet
+
+        ranked = sorted(file_scores.items(), key=lambda x: (-x[1], x[0]))
+        matches = []
+        for path, score in ranked[:MAX_MATCHES]:
+            snippet = file_snippets.get(path, "")
+            matches.append({
+                "path": path,
+                "score": round(score, 1),
+                "snippet": snippet,
+                "size": file_sizes.get(path, 0),
+            })
+
+        elapsed = (time.monotonic() - start) * 1000
+        logger.debug(f"Repomix search for '{query}': {len(matches)} matches in {elapsed:.0f}ms")
+        return {"matches": matches, "latency_ms": round(elapsed, 1)}
+
+    def _tokenize(self, text: str) -> List[str]:
+        parts = re.split(r"[/\\\.\-_ ]", text.lower())
+        result = []
+        for part in parts:
+            if len(part) >= 2:
+                result.append(part)
+            sub_parts = re.findall(r"[a-z]+|[A-Z][a-z]*|\d+", part)
+            for sp in sub_parts:
+                sp_lower = sp.lower()
+                if len(sp_lower) >= 2 and sp_lower != part:
+                    result.append(sp_lower)
+        return list(set(result))
+
+    async def cleanup(self) -> None:
+        self._ready = False
+        self._pack_content = None
+        if self._pack_path and self._pack_path.exists():
+            try:
+                self._pack_path.unlink()
+                logger.info("Repomix pack deleted")
+            except OSError as e:
+                logger.warning(f"Failed to delete repomix pack: {e}")
+        self._pack_path = None
+
+    @property
+    def is_ready(self) -> bool:
+        return self._ready
+
+
+_repomix_backend: Optional[RepomixBackend] = None
+
+
+def get_repomix_backend() -> RepomixBackend:
+    global _repomix_backend
+    if _repomix_backend is None:
+        _repomix_backend = RepomixBackend()
+    return _repomix_backend