sharkit 0.1.0__py3-none-any.whl

sharkit/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+__app_name__ = "sharkit"

sharkit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from sharkit.app import main
+
+sys.exit(main())

sharkit/app.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from sharkit.commands.builtins import BUILTIN_COMMANDS
+from sharkit.commands.registry import CommandRegistry
+from sharkit.config.manager import ConfigManager
+from sharkit.console.repl import Console
+from sharkit.exceptions import SharkitError
+from sharkit.history.manager import HistoryManager
+from sharkit.modules.loader import discover_modules
+from sharkit.modules.registry import ModuleRegistry
+from sharkit.network.client import HttpClient
+from sharkit.output.renderer import Renderer
+
+NON_LINUX_MESSAGE = (
+    "sharkit is a shark.\n"
+    "it was built for open water,\n"
+    "where it can actually swim.\n"
+    "\n"
+    "windows/mac is more of a glass aquarium.\n"
+    "tidy, bright, and a little too enclosed.\n"
+    "\n"
+    "the shark doesn't dislike the aquarium.\n"
+    "it just wasn't shaped for it,\n"
+    "and it shows.\n"
+    "\n"
+    "find us in linux.\n"
+    "mrrp :3"
+)
+
+
+def main() -> int:
+    sys.stdout.write("\033[2J\033[3J\033[H")
+    sys.stdout.flush()
+    renderer = Renderer()
+
+    if sys.platform != "linux":
+        renderer.banner(module_count=0, message=NON_LINUX_MESSAGE)
+        return 1
+
+    config_manager = ConfigManager()
+
+    history_manager = HistoryManager()
+
+    module_registry = ModuleRegistry()
+    modules_dir = Path(__file__).parent / "modules"
+    discovered = discover_modules(modules_dir)
+    for module_class, module_path in discovered:
+        module_registry.register_module(module_class, module_path)
+
+    command_registry = CommandRegistry()
+    for command_class in BUILTIN_COMMANDS:
+        command_registry.register_command(command_class)
+
+    http_client = HttpClient()
+
+    renderer.banner(module_count=len(discovered))
+    print()
+
+    console = Console(
+        command_registry=command_registry,
+        module_registry=module_registry,
+        config_manager=config_manager,
+        history_manager=history_manager,
+        renderer=renderer,
+    )
+
+    try:
+        console.run()
+    except KeyboardInterrupt:
+        print()
+    except SharkitError as exc:
+        renderer.error(str(exc))
+        return 1
+    finally:
+        http_client.close()
+
+    return 0

sharkit/commands/__init__.py

@@ -0,0 +1,10 @@
+from sharkit.commands.base import Command, CommandContext
+from sharkit.commands.builtins import BUILTIN_COMMANDS
+from sharkit.commands.registry import CommandRegistry
+
+__all__ = [
+    "Command",
+    "CommandContext",
+    "CommandRegistry",
+    "BUILTIN_COMMANDS",
+]

sharkit/commands/base.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CommandContext:
+    session: dict[str, Any] = field(default_factory=dict)
+    modules: list[Any] = field(default_factory=list)
+    current_module: str | None = None
+    output: Any = None
+
+
+class Command(ABC):
+    name: str
+    aliases: list[str] = []
+    description: str = ""
+    usage: str = ""
+    options: list[tuple[str, str]] = []
+    notes: str = ""
+
+    @abstractmethod
+    def execute(self, context: CommandContext, args: list[str]) -> str | None: ...
+
+    def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
+        return True, None
+
+    def format_help(self) -> str:
+        usage = self.usage or self.name
+        lines = [f"Usage: {usage}", "", self.description]
+        if self.notes:
+            lines.append("")
+            lines.append(self.notes)
+        if self.options:
+            lines.append("")
+            lines.append("OPTIONS:")
+            lines.append("")
+            max_flag = max((len(f) for f, _ in self.options), default=0)
+            for flag, desc in self.options:
+                lines.append(f"    {flag:<{max_flag}}  {desc}")
+        return "\n".join(lines)

sharkit/commands/builtins.py

@@ -0,0 +1,493 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from sharkit import __version__
+from sharkit.commands.base import Command, CommandContext
+from sharkit.modules.base import Module
+
+
+def _get_module_instance(context: CommandContext) -> Module | None:
+    module_name = context.current_module
+    if module_name is None:
+        return None
+    module_registry = context.session.get("module_registry")
+    if module_registry is None:
+        return None
+    module_cls = module_registry.get_module(module_name)
+    if module_cls is None:
+        return None
+    instances: dict[str, Module] = context.session.setdefault("module_instances", {})
+    if module_name not in instances:
+        instances[module_name] = module_cls()
+    return instances[module_name]
+
+
+class HelpCommand(Command):
+    name = "help"
+    aliases = ["h", "?"]
+    description = "Show available commands or help for a specific command"
+    usage = "help [command]"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        if args:
+            return self._show_command_help(context, args[0])
+        return self._show_all_commands(context)
+
+    def _show_all_commands(self, context: CommandContext) -> str | None:
+        registry = context.session.get("command_registry")
+        if registry is None:
+            return "No command registry available."
+        renderer = context.session.get("renderer")
+        if renderer is None:
+            return "No command registry available."
+        rows = []
+        for cmd_class in registry.get_all_commands():
+            aliases = ", ".join(cmd_class.aliases)
+            rows.append([cmd_class.name, cmd_class.description, aliases])
+        renderer.table("help", ["Command", "Description", "Aliases"], rows)
+        return None
+
+    def _show_command_help(self, context: CommandContext, name: str) -> str | None:
+        registry = context.session.get("command_registry")
+        renderer = context.session.get("renderer")
+        if registry is None or renderer is None:
+            return "No command registry available."
+        try:
+            cmd_class = registry.get_command(name)
+        except Exception:
+            return f'Command "{name}" not found.'
+        if cmd_class is None:
+            return f'Command "{name}" not found.'
+        renderer.panel(cmd_class.name, cmd_class().format_help())
+        return None
+
+
+class BannerCommand(Command):
+    name = "banner"
+    aliases = ["logo"]
+    description = "Show sharkit banner"
+    usage = "banner"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        renderer = context.session.get("renderer")
+        if renderer is None:
+            return f"sharkit v{__version__}"
+        module_registry = context.session.get("module_registry")
+        module_count = len(module_registry.get_all_modules()) if module_registry else 0
+        renderer.banner(module_count=module_count)
+        return None
+
+
+class VersionCommand(Command):
+    name = "version"
+    aliases = ["ver"]
+    description = "Show sharkit version"
+    usage = "version"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        return f"sharkit v{__version__}"
+
+
+class StatusCommand(Command):
+    name = "status"
+    aliases = []
+    description = "Show framework status"
+    usage = "status"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        module_registry = context.session.get("module_registry")
+        module_count = len(module_registry.get_all_modules()) if module_registry else 0
+        current = context.current_module or "none"
+        lines = [
+            f"modules     {module_count}",
+            f"current     {current}",
+            "status      ready",
+        ]
+        return "\n".join(lines)
+
+
+class UseCommand(Command):
+    name = "use"
+    aliases = []
+    description = "Select a module"
+    usage = "use <module_path>"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        valid, error = self.validate_args(args)
+        if not valid:
+            return error
+        module_path = args[0]
+        module_registry = context.session.get("module_registry")
+        if module_registry is not None and module_registry.get_module(module_path) is None:
+            return f'Module "{module_path}" not found.\nTry: search {module_path}'
+        context.current_module = module_path
+        return f'Module "{module_path}" selected.'
+
+    def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
+        if not args:
+            return False, f"Usage: {self.usage}"
+        return True, None
+
+
+class BackCommand(Command):
+    name = "back"
+    aliases = []
+    description = "Deselect current module"
+    usage = "back"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        if context.current_module is None:
+            return "No module is currently selected."
+        previous = context.current_module
+        context.current_module = None
+        return f'Deselected module "{previous}".'
+
+
+class InfoCommand(Command):
+    name = "info"
+    aliases = []
+    description = "Show info about current module"
+    usage = "info"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        if context.current_module is None:
+            return "No module selected. Use 'use <module>' first."
+        module_registry = context.session.get("module_registry")
+        if module_registry is None:
+            return f"Module: {context.current_module}"
+        try:
+            module_cls = module_registry.get_module(context.current_module)
+            metadata = module_cls.metadata
+            lines = [
+                f"description   {metadata.description}",
+                f"category      {metadata.category}",
+                f"author        {metadata.author}",
+                f"version       {metadata.version}",
+                f"safety        {metadata.safety}",
+            ]
+            return "\n".join(lines)
+        except Exception:
+            return f"Module: {context.current_module}"
+
+
+class ShowCommand(Command):
+    name = "show"
+    aliases = []
+    description = "Show tools or module options"
+    usage = "show <tools|options> [module]"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        if not args:
+            if context.current_module is not None:
+                return self._show_options(context, None)
+            return self._show_tools(context)
+        if args[0] == "options":
+            return self._show_options(context, args[1] if len(args) > 1 else None)
+        if args[0] == "tools":
+            return self._show_tools(context)
+        return f"Unknown show subcommand: {args[0]}\nUsage: {self.usage}"
+
+    def _show_tools(self, context: CommandContext) -> str | None:
+        module_registry = context.session.get("module_registry")
+        renderer = context.session.get("renderer")
+        if module_registry is None or renderer is None:
+            return "Module registry not available."
+        all_modules = module_registry.get_all_modules()
+        if not all_modules:
+            return "No modules available."
+        rows = [
+            [module_path, module_cls.metadata.description]
+            for module_path, module_cls in all_modules.items()
+        ]
+        renderer.table("show > tools", ["Module", "Description"], rows)
+        return None
+
+    def _show_options(self, context: CommandContext, module_arg: str | None) -> str | None:
+        module_registry = context.session.get("module_registry")
+        renderer = context.session.get("renderer")
+        if module_registry is None or renderer is None:
+            return "Module registry not available."
+        if module_arg is not None:
+            module_cls = module_registry.get_module(module_arg)
+            if module_cls is None:
+                return f'Module "{module_arg}" not found.\nTry: show tools'
+            instance = module_cls()
+            title_module = module_cls.metadata.name
+        else:
+            if context.current_module is None:
+                return "No module selected. Use 'show tools' or 'use <module>' first."
+            module_cls = module_registry.get_module(context.current_module)
+            if module_cls is None:
+                return "Current module not found."
+            instance = _get_module_instance(context)
+            if instance is None:
+                return "Module registry not available."
+            title_module = module_cls.metadata.name
+        try:
+            options = instance.get_options()
+            if not options:
+                return "This module has no options."
+            rows = []
+            for opt in options.values():
+                value = opt.value or opt.default or "not set"
+                required = " (required)" if opt.required else ""
+                rows.append([opt.name, value, f"{opt.description}{required}"])
+            renderer.table(
+                f"show > options > {title_module}",
+                ["Name", "Value", "Description"],
+                rows,
+            )
+            return None
+        except Exception:
+            return "Could not retrieve options for module."
+
+
+class SetCommand(Command):
+    name = "set"
+    aliases = []
+    description = "Set option value for current module"
+    usage = "set <option> <value>"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        valid, error = self.validate_args(args)
+        if not valid:
+            return error
+        if context.current_module is None:
+            return "No module selected. Use 'use <module>' first."
+        module_instance = _get_module_instance(context)
+        if module_instance is None:
+            return "Module registry not available."
+        try:
+            options = module_instance.get_options()
+            key = args[0]
+            if key not in options:
+                available = ", ".join(options.keys())
+                return f'Option "{key}" not found.\nAvailable options: {available}'
+            module_instance.set_option(key, " ".join(args[1:]))
+            return f"Set {key} = {' '.join(args[1:])}"
+        except Exception as e:
+            return f"Failed to set option: {e}"
+
+    def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
+        if len(args) < 2:
+            return False, f"Usage: {self.usage}"
+        return True, None
+
+
+class UnsetCommand(Command):
+    name = "unset"
+    aliases = []
+    description = "Unset option value"
+    usage = "unset <option>"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        valid, error = self.validate_args(args)
+        if not valid:
+            return error
+        if context.current_module is None:
+            return "No module selected. Use 'use <module>' first."
+        module_instance = _get_module_instance(context)
+        if module_instance is None:
+            return "Module registry not available."
+        try:
+            options = module_instance.get_options()
+            key = args[0]
+            if key not in options:
+                available = ", ".join(options.keys())
+                return f'Option "{key}" not found.\nAvailable options: {available}'
+            module_instance.set_option(key, options[key].default or "")
+            return f"Unset {key}."
+        except Exception as e:
+            return f"Failed to unset option: {e}"
+
+    def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
+        if not args:
+            return False, f"Usage: {self.usage}"
+        return True, None
+
+
+class RunCommand(Command):
+    name = "run"
+    aliases = ["sharkit"]
+    description = "Execute current module"
+    usage = "run"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        if context.current_module is None:
+            return "No module selected. Use 'use <module>' first."
+        module_instance = _get_module_instance(context)
+        if module_instance is None:
+            return "Module registry not available."
+        try:
+            options = module_instance.get_options()
+            option_values = {k: v.value or v.default or "" for k, v in options.items()}
+            config_dir = context.session.get("config_dir") or Path("/tmp")
+            from sharkit.modules.base import ExecutionContext
+
+            exec_context = ExecutionContext(
+                module_name=context.current_module,
+                options=option_values,
+                config_dir=config_dir,
+            )
+            result = module_instance.execute(exec_context)
+            renderer = context.session.get("renderer")
+            if result.success:
+                if renderer is not None:
+                    renderer.result(result.data)
+                    return None
+                lines = [f"{key}: {value}" for key, value in result.data.items()]
+                return "\n".join(lines) if lines else "Module executed successfully."
+            if renderer is not None:
+                renderer.error(f"Module execution failed: {result.error}")
+                return None
+            return f"Module execution failed: {result.error}"
+        except Exception as e:
+            return f"Module execution error: {e}"
+
+
+class SearchCommand(Command):
+    name = "search"
+    aliases = ["find"]
+    description = "Search modules by query"
+    usage = "search <query>"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        valid, error = self.validate_args(args)
+        if not valid:
+            return error
+        query = args[0].lower()
+        module_registry = context.session.get("module_registry")
+        if module_registry is None:
+            return "Module registry not available."
+        try:
+            all_modules = module_registry.get_all_modules()
+            matches = []
+            for module_path, module_cls in all_modules.items():
+                metadata = module_cls.metadata
+                searchable = f"{metadata.name} {metadata.description} {metadata.category}".lower()
+                if query in searchable or query in module_path.lower():
+                    matches.append(f"  {module_path:<30}{metadata.description}")
+            if not matches:
+                return f'No modules found matching "{query}".'
+            lines = [f"Modules matching \"{query}\":"] + matches
+            return "\n".join(lines)
+        except Exception as e:
+            return f"Search failed: {e}"
+
+    def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
+        if not args:
+            return False, f"Usage: {self.usage}"
+        return True, None
+
+
+class HistoryCommand(Command):
+    name = "history"
+    aliases = []
+    description = "Show command history"
+    usage = "history [options]"
+    options = [
+        ("-a, --all-commands", "Show all commands in history."),
+        ("-c, --clear", "Clear command history and history file."),
+        ("-h, --help", "Help banner."),
+        ("-n <num>", "Show the last n commands."),
+    ]
+    notes = (
+        "By default only the last 100 entries are shown. Use -a to dump them all.\n"
+        "-c wipes both the live history and the history file on disk. mrrp :3\n"
+        "Lead a command with a space and it stays out of the history."
+    )
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        clear = False
+        all_commands = False
+        limit = 100
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg in ("-c", "--clear"):
+                clear = True
+            elif arg in ("-a", "--all-commands"):
+                all_commands = True
+            elif arg in ("-n", "--last"):
+                i += 1
+                if i >= len(args):
+                    return f"Error: {arg} requires a number."
+                try:
+                    limit = int(args[i])
+                except ValueError:
+                    return f"Error: invalid number for {arg}: {args[i]}"
+            elif arg in ("-h", "--help"):
+                return self.format_help()
+            else:
+                return f"Unknown option: {arg}\nUsage: {self.usage}"
+            i += 1
+
+        manager = context.session.get("history_manager")
+        if manager is None:
+            return "History manager not available."
+
+        if clear:
+            manager.clear()
+            context.session["history"] = []
+            return "[+] Command history and history file cleared"
+
+        all_entries = manager.get_history(10_000_000)
+        if all_commands:
+            limit = len(all_entries)
+        if limit < 0:
+            limit = 0
+        shown = all_entries[-limit:] if limit else all_entries
+        if not shown:
+            return "No command history."
+        start = len(all_entries) - len(shown) + 1
+        rows = [[str(start + idx), cmd] for idx, cmd in enumerate(shown)]
+        renderer = context.session.get("renderer")
+        if renderer is None:
+            return "Renderer not available."
+        renderer.table("history", ["#", "Command"], rows)
+        return None
+
+
+class ClearCommand(Command):
+    name = "clear"
+    aliases = ["cls"]
+    description = "Clear terminal"
+    usage = "clear"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        renderer = context.session.get("renderer")
+        if renderer is not None:
+            renderer.raw("\033[2J\033[3J\033[H")
+            return None
+        return "\033[2J\033[3J\033[H"
+
+
+class ExitCommand(Command):
+    name = "exit"
+    aliases = ["quit"]
+    description = "Exit application"
+    usage = "exit"
+
+    def execute(self, context: CommandContext, args: list[str]) -> str | None:
+        context.session["exit_requested"] = True
+        return "Bye! :3"
+
+
+BUILTIN_COMMANDS: list[type[Command]] = [
+    HelpCommand,
+    BannerCommand,
+    VersionCommand,
+    StatusCommand,
+    UseCommand,
+    BackCommand,
+    InfoCommand,
+    ShowCommand,
+    SetCommand,
+    UnsetCommand,
+    RunCommand,
+    SearchCommand,
+    HistoryCommand,
+    ClearCommand,
+    ExitCommand,
+]

sharkit/commands/registry.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from sharkit.commands.base import Command
+from sharkit.exceptions import CommandNotFoundError
+
+
+class CommandRegistry:
+    def __init__(self) -> None:
+        self._commands: dict[str, type[Command]] = {}
+        self._aliases: dict[str, str] = {}
+
+    def register_command(self, command_class: type[Command]) -> None:
+        self._commands[command_class.name] = command_class
+        for alias in command_class.aliases:
+            self._aliases[alias] = command_class.name
+
+    def get_command(self, name: str) -> type[Command]:
+        canonical = self._aliases.get(name, name)
+        command = self._commands.get(canonical)
+        if command is None:
+            raise CommandNotFoundError(name)
+        return command
+
+    def get_all_commands(self) -> list[type[Command]]:
+        return list(self._commands.values())
+
+    def get_command_names(self) -> list[str]:
+        return sorted(self._commands.keys())
+
+    def get_completions(self, prefix: str) -> list[str]:
+        names = set(self._commands.keys()) | set(self._aliases.keys())
+        return sorted(name for name in names if name.startswith(prefix))