shellmate-cli 3.0.0__py3-none-any.whl

shellmate/rules/engine.py

@@ -0,0 +1,200 @@
+import os
+import re
+import yaml
+from shellmate.parser.command_parser import parse_command
+
+RULES_DIR = os.path.join(os.path.dirname(__file__), "definitions")
+
+
+def load_rules():
+    rules = []
+    if not os.path.isdir(RULES_DIR):
+        return rules
+
+    for filename in sorted(os.listdir(RULES_DIR)):
+        if filename.endswith((".yaml", ".yml")):
+            filepath = os.path.join(RULES_DIR, filename)
+            try:
+                with open(filepath, "r") as f:
+                    file_rules = yaml.safe_load(f)
+                    if file_rules:
+                        for rule in file_rules:
+                            rule["source"] = filename
+                        rules.extend(file_rules)
+            except yaml.YAMLError as e:
+                raise ValueError(f"Error parsing {filename}: {e}")
+
+    return rules
+
+
+def match_rule(command_string, rules):
+    parsed = parse_command(command_string)
+
+    for rule in rules:
+        if rule.get("pipeline") and "|" in command_string:
+            result = _match_pipeline_rule_on_string(command_string, rule)
+        else:
+            result = _match_single_rule(parsed, rule)
+        if result["matched"]:
+            return result
+
+    return {"matched": False, "risk": None, "confidence": 0.0}
+
+
+def _match_pipeline_rule_on_string(command_string, rule):
+    pattern = rule.get("pattern", [])
+    parts = [p.strip() for p in command_string.split("|")]
+    if len(parts) != len([p for p in pattern if not p.get("operator")]):
+        return {"matched": False}
+
+    cmd_index = 0
+    for pattern_item in pattern:
+        if pattern_item.get("operator"):
+            continue
+        part = parts[cmd_index]
+        expected_program = pattern_item.get("program")
+        if expected_program and not part.startswith(expected_program):
+            return {"matched": False}
+        cmd_index += 1
+
+    return _build_match_result(rule)
+
+
+def _match_single_rule(parsed_command, rule):
+    if isinstance(parsed_command, dict) and parsed_command.get("pipeline"):
+        segments = parsed_command.get("segments", [])
+        for seg_type, seg_data in segments:
+            if seg_type == "command":
+                result = _match_single_command_rule(seg_data, rule)
+                if result["matched"]:
+                    return result
+        return {"matched": False}
+
+    return _match_single_command_rule(parsed_command, rule)
+
+
+def _match_pipeline_rule(parsed_command, rule):
+    pattern = rule.get("pattern", [])
+
+    if isinstance(parsed_command, dict) and parsed_command.get("pipeline"):
+        segments = parsed_command.get("segments", [])
+        if len(segments) != len(pattern):
+            return {"matched": False}
+
+        for (seg_type, seg_data), pattern_item in zip(segments, pattern):
+            if seg_type == "command":
+                expected_program = pattern_item.get("program")
+                if isinstance(seg_data, dict):
+                    if seg_data.get("program") != expected_program:
+                        return {"matched": False}
+            elif seg_type == "pipe":
+                expected_op = pattern_item.get("operator")
+                if seg_data != expected_op:
+                    return {"matched": False}
+
+        return _build_match_result(rule)
+
+    if isinstance(parsed_command, dict):
+        cmd_str = " ".join(filter(None, [
+            parsed_command.get("program", ""),
+            *([parsed_command.get("subcommand", "")] if parsed_command.get("subcommand") else []),
+            *([str(f) for f in parsed_command.get("flags", [])] if isinstance(parsed_command.get("flags"), list) else []),
+            *parsed_command.get("arguments", []),
+        ]))
+    else:
+        cmd_str = str(parsed_command)
+
+    if "|" not in cmd_str:
+        return {"matched": False}
+
+    parts = [p.strip() for p in cmd_str.split("|")]
+    if len(parts) != len(pattern):
+        return {"matched": False}
+
+    for part, pattern_item in zip(parts, pattern):
+        if pattern_item.get("operator"):
+            continue
+        expected_program = pattern_item.get("program")
+        if expected_program and not part.startswith(expected_program):
+            return {"matched": False}
+
+    return _build_match_result(rule)
+
+
+def _match_single_command_rule(parsed_command, rule):
+    if isinstance(parsed_command, dict):
+        cmd_program = parsed_command.get("program")
+    else:
+        try:
+            import shlex
+            tokens = shlex.split(str(parsed_command))
+            cmd_program = tokens[0] if tokens else None
+        except ValueError:
+            return {"matched": False}
+
+    expected_program = rule.get("program")
+    if cmd_program != expected_program:
+        if expected_program and cmd_program:
+            if not cmd_program.startswith(expected_program + "."):
+                return {"matched": False}
+        else:
+            return {"matched": False}
+
+    expected_flags = rule.get("flags", [])
+    if expected_flags:
+        if isinstance(parsed_command, dict):
+            cmd_flags = parsed_command.get("flags", [])
+            flag_values = {f["flag"] for f in cmd_flags} if isinstance(cmd_flags, list) else set()
+            if not any(f in flag_values for f in expected_flags):
+                return {"matched": False}
+        else:
+            cmd_str = str(parsed_command)
+            if not any(f in cmd_str for f in expected_flags):
+                return {"matched": False}
+
+    expected_args = rule.get("arguments", [])
+    if expected_args:
+        if isinstance(parsed_command, dict):
+            cmd_args = parsed_command.get("arguments", [])
+            arg_strings = " ".join(cmd_args) if isinstance(cmd_args, list) else str(cmd_args)
+        else:
+            arg_strings = str(parsed_command)
+
+        if not any(re.search(pat, arg_strings) for pat in expected_args):
+            return {"matched": False}
+
+    return _build_match_result(rule)
+
+
+def _build_match_result(rule):
+    return {
+        "matched": True,
+        "rule_id": rule.get("id"),
+        "category": rule.get("category"),
+        "severity": rule.get("severity", "MEDIUM"),
+        "risk": rule.get("severity", "MEDIUM"),
+        "confidence": rule.get("confidence", 0.8),
+        "description": rule.get("message", rule.get("description", "")),
+        "message": rule.get("message", rule.get("description", "")),
+        "rule": rule,
+    }
+
+
+def validate_rules():
+    rules = load_rules()
+    rule_ids = {}
+    for rule in rules:
+        rid = rule.get("id")
+        if not rid:
+            raise ValueError(f"Rule missing 'id' in {rule.get('source', 'unknown')}")
+        if rid in rule_ids:
+            raise ValueError(f"Duplicate rule ID: {rid}")
+        rule_ids[rid] = True
+        if not rule.get("category"):
+            raise ValueError(f"Rule {rid} missing 'category'")
+        if not rule.get("severity"):
+            raise ValueError(f"Rule {rid} missing 'severity'")
+        if not rule.get("program") and not rule.get("pipeline"):
+            raise ValueError(f"Rule {rid} missing 'program' or 'pipeline'")
+
+    return rules

shellmate/sanitizer/typo_detector.py

@@ -0,0 +1,114 @@
+import re
+import shlex
+
+TRAILING_CHARS = re.compile(r"[,;.]$")
+MULTI_SPACE = re.compile(r"\s{2,}")
+
+
+def normalize_whitespace(command):
+    return MULTI_SPACE.sub(" ", command.strip())
+
+
+def detect_trailing_char(command):
+    stripped = command.strip()
+    match = TRAILING_CHARS.search(stripped)
+    if match:
+        trailing = match.group()
+        corrected = stripped.rstrip(",. ;")
+        return {
+            "detected": True,
+            "trailing": trailing,
+            "original": command,
+            "suggestion": corrected,
+            "message": f"Did you mean: {corrected}",
+        }
+    return {"detected": False}
+
+
+def detect_duplicate_flags(tokens):
+    seen = []
+    duplicates = []
+    for token in tokens:
+        if token.startswith("-"):
+            if token in seen:
+                duplicates.append(token)
+            else:
+                seen.append(token)
+    if duplicates:
+        return {
+            "detected": True,
+            "duplicates": duplicates,
+            "message": f"Duplicate flag(s) detected: {', '.join(duplicates)}",
+        }
+    return {"detected": False}
+
+
+def validate_syntax(command):
+    in_single = False
+    in_double = False
+    i = 0
+    char_count = len(command)
+
+    errors = []
+
+    while i < char_count:
+        c = command[i]
+        if c == "\\" and i + 1 < char_count:
+            i += 2
+            continue
+        if c == "'" and not in_double:
+            in_single = not in_single
+        elif c == '"' and not in_single:
+            in_double = not in_double
+        i += 1
+
+    if in_single:
+        errors.append("Unmatched single quote")
+    if in_double:
+        errors.append("Unmatched double quote")
+
+    if not errors:
+        try:
+            shlex.split(command)
+        except ValueError as e:
+            errors.append(str(e))
+
+    token_pattern = re.findall(r'(?:^|\s)([<>]{2,3})(?:\s|$)', command)
+    for token in token_pattern:
+        if token not in (">", "<", ">>", "<<", ">&", "<>", "2>", "2>>"):
+            if token not in errors:
+                errors.append(f"Invalid redirect operator: {token}")
+
+    return {
+        "valid": len(errors) == 0,
+        "errors": errors,
+    }
+
+
+def sanitize(command):
+    result = {
+        "original": command,
+        "normalized": normalize_whitespace(command),
+        "trailing_char": None,
+        "duplicate_flags": None,
+        "syntax": None,
+        "correction": None,
+    }
+
+    trailing = detect_trailing_char(result["normalized"])
+    if trailing["detected"]:
+        result["trailing_char"] = trailing
+        result["correction"] = trailing["suggestion"]
+
+    try:
+        tokens = shlex.split(result["normalized"])
+        dup = detect_duplicate_flags(tokens)
+        if dup["detected"]:
+            result["duplicate_flags"] = dup
+    except ValueError:
+        tokens = result["normalized"].split()
+
+    syntax = validate_syntax(result["normalized"])
+    result["syntax"] = syntax
+
+    return result

shellmate/ui/__init__.py

@@ -0,0 +1,10 @@
+from shellmate.ui.analysis import render_analysis
+from shellmate.ui.status import render_status
+from shellmate.ui.banner import print_banner, print_usage
+
+__all__ = [
+    "render_analysis",
+    "render_status",
+    "print_banner",
+    "print_usage",
+]

shellmate/ui/analysis.py

@@ -0,0 +1,164 @@
+from rich.console import Console, Group
+from rich.table import Table
+from rich.text import Text
+from rich.panel import Panel
+from rich.columns import Columns
+from rich.rule import Rule
+
+console = Console(width=120)
+
+RISK_STYLES = {
+    "SAFE": ("green", "[OK]", "bold green", "green"),
+    "LOW": ("blue", "[i]", "bold blue", "blue"),
+    "MEDIUM": ("yellow", "[!]", "bold yellow", "yellow"),
+    "HIGH": ("red", "[!!]", "bold red", "red"),
+    "CRITICAL": ("bold red", "[!!!]", "bold white on red", "red"),
+}
+
+SEVERITY_ORDER = {"SAFE": 0, "LOW": 1, "MEDIUM": 2, "HIGH": 3, "CRITICAL": 4}
+
+
+def _confidence_bar(confidence: float) -> str:
+    bar_len = 12
+    filled = int(confidence * bar_len)
+    bar = "█" * filled + "░" * (bar_len - filled)
+    color = "green" if confidence >= 0.8 else "yellow" if confidence >= 0.5 else "red"
+    return f"[{color}]{bar}[/{color}]"
+
+
+def _latency_table(latency: dict) -> Table:
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Stage", style="dim")
+    table.add_column("Time", justify="right")
+    for stage, ms in sorted(latency.items(), key=lambda x: -x[1]):
+        ms_str = f"{ms:.0f}ms" if ms > 0 else "<1ms"
+        table.add_row(f"  {stage}", ms_str)
+    return table
+
+
+def render_analysis(result: dict):
+    risk = result.get("risk", "UNKNOWN").upper()
+    confidence = result.get("confidence", 0.0)
+    message = result.get("message", "") or result.get("explanation", "")
+    alternatives = result.get("alternatives", [])
+    context_used = result.get("context_used", {})
+    latency = result.get("latency", {})
+    total_ms = result.get("total_ms", 0)
+    early_exit = result.get("early_exit")
+    cached = result.get("cached", False)
+    warning = result.get("supervisor_warning")
+    guide = result.get("command_guide")
+
+    color, prefix, risk_style, border = RISK_STYLES.get(risk, ("white", "[?]", "white", "white"))
+
+    risk_header = Text()
+    risk_header.append(f"{prefix} {risk}", style=risk_style)
+    if cached:
+        risk_header.append("  (cached)", style="dim italic")
+
+    elements = [risk_header]
+
+    if confidence > 0:
+        bar = _confidence_bar(confidence)
+        elements.append(Text.assemble(" ", bar, f"  {confidence:.0%}", style="dim"))
+
+    if message:
+        max_len = 500
+        truncated = message[:max_len] + "..." if len(message) > max_len else message
+        msg = Text(truncated)
+        msg.stylize("white")
+        if len(truncated) > 100:
+            elements.append(Panel(msg, border_style=border, padding=(0, 1)))
+        else:
+            elements.append(Text(f"  {truncated}"))
+
+    failed_cred = result.get("failed_credential")
+    failed_prov = result.get("failed_provider")
+    if failed_cred or failed_prov:
+        which = failed_cred or (f"{failed_prov}_API_KEY".upper() if failed_prov else "API key")
+        elements.append(
+            Text(f"  Failed credential: {which}", style="bold yellow")
+        )
+
+    if early_exit:
+        exit_msgs = {
+            "sanitizer": "Corrected by typo sanitizer",
+            "rule_engine": "Matched deterministic rule",
+            "cache": "Returned from cache",
+        }
+        exit_label = exit_msgs.get(early_exit, early_exit)
+        elements.append(Text(f"  [dim]Early exit:[/] [italic]{exit_label}[/]"))
+
+    if warning:
+        warning_panel = Panel(
+            Text(f"! {warning}", style="yellow"),
+            border_style="yellow",
+            padding=(0, 1),
+        )
+        elements.append(warning_panel)
+
+    if alternatives:
+        alt_label = "Suggestions:" if risk in ("SAFE", "LOW") else "Safer alternatives:"
+        alt_parts = [Text(alt_label, style="bold")]
+        for i, alt in enumerate(alternatives[:5], 1):
+            alt_parts.append(Text(f"  {i}. {alt}"))
+        elements.append(Group(*alt_parts))
+
+    if context_used:
+        ctx_parts = []
+        if context_used.get("watcher"):
+            ctx_parts.append("watcher")
+        if context_used.get("librarian"):
+            ctx_parts.append("librarian")
+        if ctx_parts:
+            ct = Text(f"   Context: {', '.join(ctx_parts)}")
+            ct.stylize("dim italic")
+            elements.append(ct)
+
+    if guide:
+        guide_parts = []
+        if guide.get("intent_guess"):
+            guide_parts.append(Text(guide["intent_guess"], style="italic"))
+        if guide.get("when_to_use"):
+            guide_parts.append(Text(f"  When to use: {guide['when_to_use']}"))
+        if guide.get("parameters"):
+            guide_parts.append(Text("  Parameters:", style="bold dim"))
+            for p in guide.get("parameters") or []:
+                guide_parts.append(Text(f"    • {p}"))
+        suggested = guide.get("suggested_command") or guide.get("example_command")
+        if suggested:
+            guide_parts.append(Text.assemble(
+                "  Use: ", (suggested, "bold cyan"),
+            ))
+        if guide_parts:
+            guide_panel = Panel(
+                Group(*guide_parts),
+                border_style="cyan",
+                padding=(0, 1),
+                title="[bold cyan]Command guide[/bold cyan]",
+            )
+            elements.append(guide_panel)
+
+    if latency:
+        elements.append(Text("Latency breakdown:", style="bold dim"))
+        elements.append(_latency_table(latency))
+
+    if total_ms:
+        elements.append(Text(f"  Total: {total_ms:.0f}ms", style="dim"))
+
+    main_panel = Panel(
+        Group(*elements),
+        border_style=border,
+        padding=(1, 2),
+        title=f"[{color}]{risk} Analysis[/{color}]",
+        title_align="left",
+    )
+    console.print(main_panel)
+
+    suggested_cmd = guide and (guide.get("suggested_command") or guide.get("example_command"))
+    if suggested_cmd:
+        tip = Text.assemble(
+            ("> Tip: ", "bold yellow"),
+            (f"Try `{suggested_cmd}` for this operation", "white"),
+        )
+        console.print(tip)