sharkit 0.2.1.dev5__tar.gz → 1.0.0.dev2__tar.gz

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sharkit
-Version: 0.2.1.dev5
+Version: 1.0.0.dev2
 Summary: OSINT / HUMINT / GEOINT research framework
 Project-URL: Homepage, https://github.com/sshsrv/sharkit
 Project-URL: Repository, https://github.com/sshsrv/sharkit

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sharkit"
-version = "0.2.1.dev5"
+version = "1.0.0.dev2"
 description = "OSINT / HUMINT / GEOINT research framework"
 readme = "README.md"
 license = "MIT"

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/__init__.py

@@ -5,4 +5,4 @@ try:
 
     __version__ = _pkg_version("sharkit")
 except Exception:
-    __version__ = "0.2.0.dev1"
+    __version__ = "0.3.0.dev1"

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/__main__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import sys
 
 from sharkit.app import main

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/app.py

@@ -33,8 +33,9 @@ NON_LINUX_MESSAGE = (
 
 
 def main() -> int:
-    sys.stdout.write("\033[2J\033[3J\033[H")
-    sys.stdout.flush()
+    if sys.stdout.isatty():
+        sys.stdout.write("\033[2J\033[3J\033[H")
+        sys.stdout.flush()
     renderer = Renderer()
 
     if sys.platform == "win32":
@@ -69,6 +70,7 @@ def main() -> int:
         history_manager=history_manager,
         renderer=renderer,
     )
+    console._session_data["http_client"] = http_client
 
     try:
         console.run()

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/commands/base.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, ClassVar
 
 
 @dataclass
@@ -15,10 +15,10 @@ class CommandContext:
 
 class Command(ABC):
     name: str
-    aliases: list[str] = []
+    aliases: ClassVar[list[str]] = []
     description: str = ""
     usage: str = ""
-    options: list[tuple[str, str]] = []
+    options: ClassVar[list[tuple[str, str]]] = []
     notes: str = ""
 
     @abstractmethod

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/commands/builtins.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
+import logging
 import sys
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 from sharkit import __version__
 from sharkit.commands.base import Command, CommandContext
+from sharkit.exceptions import CommandNotFoundError
 from sharkit.output.theme import BLUE, BOLD, GREEN, PINK, RED, RESET
 from sharkit.tools.base import Tool
 
@@ -22,6 +25,19 @@ def _normalize_bool(value: str) -> str:
     return value
 
 
+def _make_progress_callback(
+    renderer: Any, tag: str, color: str, first_progress: list[bool]
+) -> Callable[[str], None]:
+    def on_progress(msg: str) -> None:
+        if renderer is not None:
+            if first_progress[0]:
+                renderer.gutter(tag, msg, color, is_first=True)
+                first_progress[0] = False
+            else:
+                renderer.gutter(tag, msg, color, is_first=False)
+    return on_progress
+
+
 def _get_tool_instance(context: CommandContext) -> Tool | None:
     tool_name = context.current_tool
     if tool_name is None:
@@ -70,7 +86,7 @@ class HelpCommand(Command):
             return "No command registry available."
         try:
             cmd_class = registry.get_command(name)
-        except Exception:
+        except (CommandNotFoundError, KeyError):
             return f'Command "{name}" not found.'
         if cmd_class is None:
             return f'Command "{name}" not found.'
@@ -173,7 +189,7 @@ class UseCommand(Command):
     def _log(self, context: CommandContext, message: str) -> None:
         renderer = context.session.get("renderer")
         if renderer is not None:
-            renderer.log_line("use", message)
+            renderer.dash_line("use", message)
 
     def validate_args(self, args: list[str]) -> tuple[bool, str | None]:
         if not args:
@@ -194,15 +210,9 @@ class UseCommand(Command):
                     return None
                 renderer = context.session.get("renderer")
                 first_progress = [True]
-
-                def on_progress(msg: str) -> None:
-                    if renderer is not None:
-                        tag = f"install {display}"
-                        if first_progress[0]:
-                            renderer.gutter(tag, msg, GREEN, is_first=True)
-                            first_progress[0] = False
-                        else:
-                            renderer.gutter(tag, msg, GREEN, is_first=False)
+                on_progress = _make_progress_callback(
+                    renderer, f"install {display}", GREEN, first_progress
+                )
 
                 ok, message = tool_manager.install(name, spec, on_progress=on_progress)
                 if not ok:
@@ -268,7 +278,7 @@ class InfoCommand(Command):
                 f"safety        {metadata.safety}",
             ]
             return "\n".join(lines)
-        except Exception:
+        except (CommandNotFoundError, AttributeError):
             return f"Tool: {context.current_tool}"
 
 
@@ -276,39 +286,68 @@ class ShowCommand(Command):
     name = "show"
     aliases = []
     description = "Show tools or tool options"
-    usage = "show <tools|options> [tool]"
+    usage = "show <all|osint|humint|geoint|options> [tool]"
 
     def execute(self, context: CommandContext, args: list[str]) -> str | None:
         if not args:
             if context.current_tool is not None:
                 return self._show_options(context, None)
-            return self._show_tools(context)
+            return self._show_tools(context, None)
         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)
+        if args[0] == "all":
+            return self._show_tools(context, None)
+        if args[0] in ("osint", "humint", "geoint"):
+            return self._show_tools(context, args[0])
         return f"Unknown show subcommand: {args[0]}\nUsage: {self.usage}"
 
-    def _show_tools(self, context: CommandContext) -> str | None:
+    def _show_tools(self, context: CommandContext, category: str | None) -> str | None:
         tool_registry = context.session.get("tool_registry")
         tool_manager = context.session.get("tool_manager")
         renderer = context.session.get("renderer")
         if tool_registry is None or renderer is None:
             return "Tool registry not available."
+
         all_tools = tool_registry.get_all_tools()
         if not all_tools:
             return "No tools available."
+
+        def matches_category(tool_path: str, tool_cls: type) -> bool:
+            if category is None:
+                return True
+
+            normalized_category = category.lower()
+            tool_category = (tool_cls.metadata.category or "").lower()
+            first_segment = tool_category.split(".")[0]
+            return (
+                normalized_category == tool_category
+                or normalized_category == first_segment
+                or normalized_category in tool_category
+                or tool_path.lower().startswith(f"{normalized_category}/")
+            )
+
+        filtered = [
+            (tool_path, tool_cls)
+            for tool_path, tool_cls in all_tools.items()
+            if matches_category(tool_path, tool_cls)
+        ]
+
+        if not filtered:
+            return f'No tools found for category "{category}".'
+
+        title = f"show > {category or 'all'}"
         rows = []
-        for tool_path, tool_cls in all_tools.items():
-            metadata = tool_cls.metadata
-            if metadata.install is None or (
-                tool_manager is not None and tool_manager.is_installed(metadata.name)
+        for tool_path, tool_cls in sorted(filtered, key=lambda item: item[0]):
+            meta = tool_cls.metadata
+            if meta.install is None or (
+                tool_manager is not None and tool_manager.is_installed(meta.name)
             ):
                 installed = f"{BOLD}{PINK}Yes{RESET}"
             else:
                 installed = ""
-            rows.append([tool_path, installed, metadata.description])
-        renderer.table("show > tools", ["Tool", "Installed", "Description"], rows)
+            rows.append([tool_path, installed, meta.description])
+
+        renderer.table(title, ["Tool", "Installed", "Description"], rows)
         return None
 
     def _show_options(self, context: CommandContext, tool_arg: str | None) -> str | None:
@@ -319,12 +358,12 @@ class ShowCommand(Command):
         if tool_arg is not None:
             tool_cls = tool_registry.get_tool(tool_arg)
             if tool_cls is None:
-                return f'Tool "{tool_arg}" not found.\nTry: show tools'
+                return f'Tool "{tool_arg}" not found.\nTry: show all'
             instance = tool_cls()
             title_tool = tool_cls.metadata.name
         else:
             if context.current_tool is None:
-                return "No tool selected. Use 'show tools' or 'use <tool>' first."
+                return "No tool selected. Use 'show all' or 'use <tool>' first."
             tool_cls = tool_registry.get_tool(context.current_tool)
             if tool_cls is None:
                 return "Current tool not found."
@@ -338,7 +377,11 @@ class ShowCommand(Command):
                 return "This tool has no options."
             rows = []
             for opt in options.values():
-                value = opt.value or opt.default or "not set"
+                value = (
+                    opt.value
+                    if opt.value is not None
+                    else (opt.default if opt.default is not None else "not set")
+                )
                 required = " (required)" if opt.required else ""
                 rows.append([opt.name, value, f"{opt.description}{required}"])
             renderer.table(
@@ -347,7 +390,7 @@ class ShowCommand(Command):
                 rows,
             )
             return None
-        except Exception:
+        except (CommandNotFoundError, KeyError, AttributeError):
             return "Could not retrieve options for tool."
 
 
@@ -374,6 +417,8 @@ class SetCommand(Command):
                 return f'Option "{key}" not found.\nAvailable options: {available}'
             option = options[key]
             raw = " ".join(args[1:])
+            if not raw and option.required:
+                return f'Option "{key}" requires a value.'
             if option.type == "bool":
                 value = _normalize_bool(raw)
             elif option.choices:
@@ -394,7 +439,7 @@ class SetCommand(Command):
                     display = tool_registry.format_display(
                         tool_registry.get_tool_path(context.current_tool),
                     )
-                renderer.log_line(f"set {display}", f"{key} = {value}")
+                renderer.dash_line(f"set {display}", f"{key} = {value}")
                 return None
             return f"Set {key} = {value}"
         except Exception as e:
@@ -452,7 +497,10 @@ class RunCommand(Command):
             return "Tool registry not available."
         try:
             options = tool_instance.get_options()
-            option_values = {k: v.value or v.default or "" for k, v in options.items()}
+            option_values = {
+                k: v.value if v.value is not None else (v.default if v.default is not None else "")
+                for k, v in options.items()
+            }
             config_dir = context.session.get("config_dir") or Path("/tmp")
             from sharkit.tools.base import ExecutionContext
 
@@ -475,7 +523,9 @@ class RunCommand(Command):
             if result.success:
                 if result.data:
                     if renderer is not None:
-                        renderer.result(result.data)
+                        tool_name = tool_instance.metadata.name
+                        tool_color = tool_instance.metadata.color or "#888888"
+                        renderer.tool_output(result.data, tool_name, tool_color)
                         return None
                     lines = [f"{key}: {value}" for key, value in result.data.items()]
                     return "\n".join(lines) if lines else "Tool executed successfully."
@@ -486,7 +536,8 @@ class RunCommand(Command):
                 renderer.error(f"Tool execution failed: {result.error}")
                 return None
             return f"Tool execution failed: {result.error}"
-        except Exception as e:
+        except (RuntimeError, ValueError, OSError) as e:
+            logging.getLogger(__name__).exception("Tool execution error")
             return f"Tool execution error: {e}"
 
 
@@ -500,7 +551,7 @@ class SearchCommand(Command):
         valid, error = self.validate_args(args)
         if not valid:
             return error
-        query = args[0].lower()
+        query = " ".join(args).lower()
         tool_registry = context.session.get("tool_registry")
         if tool_registry is None:
             return "Tool registry not available."
@@ -648,15 +699,9 @@ class InstallCommand(Command):
             return None
         renderer = context.session.get("renderer")
         first_progress = [True]
-
-        def on_progress(msg: str) -> None:
-            if renderer is not None:
-                tag = f"install {display}"
-                if first_progress[0]:
-                    renderer.gutter(tag, msg, GREEN, is_first=True)
-                    first_progress[0] = False
-                else:
-                    renderer.gutter(tag, msg, GREEN, is_first=False)
+        on_progress = _make_progress_callback(
+            renderer, f"install {display}", GREEN, first_progress
+        )
 
         install_spec = tool_cls.metadata.install
         ok, message = tool_manager.install(
@@ -706,21 +751,12 @@ class UpgradeCommand(Command):
         tool_name = tool_cls.metadata.name
         display = tool_registry.format_display(tool_registry.get_tool_path(tool_name))
         if not tool_manager.is_installed(tool_name):
-            renderer = context.session.get("renderer")
-            if renderer is not None:
-                renderer.log_line(f"upgrade {display}", "not installed (skipped)", color=BLUE)
             return None
         renderer = context.session.get("renderer")
         first_progress = [True]
-
-        def on_progress(msg: str) -> None:
-            if renderer is not None:
-                tag = f"upgrade {display}"
-                if first_progress[0]:
-                    renderer.gutter(tag, msg, BLUE, is_first=True)
-                    first_progress[0] = False
-                else:
-                    renderer.gutter(tag, msg, BLUE, is_first=False)
+        on_progress = _make_progress_callback(
+            renderer, f"upgrade {display}", BLUE, first_progress
+        )
 
         upgrade_spec = tool_cls.metadata.install
         ok, message = tool_manager.update(
@@ -768,25 +804,12 @@ class UpgradeCommand(Command):
             name = meta.name
             display = tool_registry.format_display(tool_registry.get_tool_path(name))
             if not tool_manager.is_installed(name):
-                renderer = context.session.get("renderer")
-                if renderer is not None:
-                    renderer.log_line(f"upgrade {display}", "not installed (skipped)", color=BLUE)
                 continue
             renderer = context.session.get("renderer")
             first_progress = [True]
-
-            def on_progress(
-                msg: str,
-                _first: list[bool] = first_progress,
-                _tag: str = f"upgrade {display}",
-                _renderer: Any = renderer,
-            ) -> None:
-                if _renderer is not None:
-                    if _first[0]:
-                        _renderer.gutter(_tag, msg, BLUE, is_first=True)
-                        _first[0] = False
-                    else:
-                        _renderer.gutter(_tag, msg, BLUE, is_first=False)
+            on_progress = _make_progress_callback(
+                renderer, f"upgrade {display}", BLUE, first_progress
+            )
 
             ok, message = tool_manager.update(name, spec, on_progress=on_progress)
             if renderer is not None:

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/config/manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 from sharkit.config.paths import (
@@ -34,7 +35,7 @@ class ConfigManager:
     def _load(self) -> None:
         try:
             content = self._config_file.read_text(encoding="utf-8")
-        except OSError as exc:
+        except (OSError, UnicodeDecodeError) as exc:
             raise ConfigurationError(f"Failed to read config file: {exc}") from exc
 
         for line_number, raw_line in enumerate(content.splitlines(), start=1):
@@ -49,16 +50,13 @@ class ConfigManager:
             self._config[key.strip()] = value.strip()
 
     def _save(self) -> None:
-        lines = []
-        for key, value in sorted(self._config.items()):
-            lines.append(f"{key}={value}")
-        content = "\n".join(lines)
-        if content:
-            content += "\n"
         try:
-            self._config_file.write_text(content, encoding="utf-8")
+            tmp = self._config_file.with_suffix(".tmp")
+            lines = [f"{k}={v}" for k, v in sorted(self._config.items())]
+            tmp.write_text("\n".join(lines) + "\n" if lines else "", encoding="utf-8")
+            os.replace(tmp, self._config_file)
         except OSError as exc:
-            raise ConfigurationError(f"Failed to write config file: {exc}") from exc
+            raise ConfigurationError(f"Failed to save config: {exc}") from exc
 
     def get(self, key: str, default: str | None = None) -> str | None:
         return self._config.get(key, default)

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/config/paths.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from sharkit.exceptions import ConfigurationError
+
 _BASE_DIR_NAME = "sharkit"
 
 
@@ -11,7 +13,12 @@ def _get_xdg_config_home() -> Path:
     xdg = os.environ.get("XDG_CONFIG_HOME")
     if xdg:
         return Path(xdg)
-    return Path.home() / ".config"
+    try:
+        return Path.home() / ".config"
+    except RuntimeError:
+        raise ConfigurationError(
+            "Cannot determine home directory. Set XDG_CONFIG_HOME manually."
+        ) from None
 
 
 def get_config_dir() -> Path:

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/console/completion.py

@@ -1,10 +1,30 @@
 from __future__ import annotations
 
 from sharkit.commands.registry import CommandRegistry
+from sharkit.tools.base import OptionDefinition
 from sharkit.tools.registry import ToolRegistry
 
 
 class CompletionEngine:
+    def __init__(self) -> None:
+        self._cached_tool: str | None = None
+        self._cached_options: dict[str, OptionDefinition] | None = None
+
+    def _load_options(
+        self, tool_registry: ToolRegistry, current_tool: str
+    ) -> dict[str, OptionDefinition]:
+        if current_tool == self._cached_tool and self._cached_options is not None:
+            return self._cached_options
+        tool_cls = tool_registry.get_tool(current_tool)
+        if tool_cls is None:
+            self._cached_tool = None
+            self._cached_options = None
+            return {}
+        instance = tool_cls()
+        self._cached_options = instance.get_options()
+        self._cached_tool = current_tool
+        return self._cached_options
+
     def get_completions(
         self,
         text: str,
@@ -22,22 +42,39 @@ class CompletionEngine:
 
         if text_lower.startswith("show "):
             prefix = text_lower[5:]
-            return sorted(s for s in ("options", "tools") if s.startswith(prefix))
+            return sorted(
+                s for s in ("all", "osint", "humint", "geoint", "options")
+                if s.startswith(prefix)
+            )
 
         if text_lower.startswith("set ") or text_lower.startswith("unset "):
             if current_tool is None:
                 return []
+            is_set = text_lower.startswith("set ")
+            body = text[4:] if is_set else text[6:]
+            parts = body.split(None, 1)
+
             try:
-                tool_cls = tool_registry.get_tool(current_tool)
-                if tool_cls is None:
-                    return []
-                instance = tool_cls()
-                options = instance.get_options()
-                prefix = text_lower[4:] if text_lower.startswith("set ") else text_lower[6:]
-                return sorted(k for k in options if k.lower().startswith(prefix))
+                options = self._load_options(tool_registry, current_tool)
             except Exception:
                 return []
 
+            if len(parts) < 2:
+                prefix = parts[0] if parts else ""
+                exact = options.get(prefix)
+                if exact and exact.choices:
+                    return list(exact.choices)
+                elif exact and exact.type == "bool":
+                    return ["true", "false"]
+                return sorted(k for k in options if k.lower().startswith(prefix))
+
+            option_name = parts[0]
+            value_prefix = parts[1]
+            opt = options.get(option_name)
+            if opt is None or not opt.choices:
+                return []
+            return sorted(c for c in opt.choices if c.lower().startswith(value_prefix.lower()))
+
         if text_lower.startswith("install "):
             prefix = text_lower[8:]
             return sorted(

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/console/prompt.py

@@ -16,7 +16,19 @@ class PromptRenderer:
             formatted = tool_name
         return f"shark {formatted} > "
 
-    def render(self, prompt: str) -> list[tuple[str, str]]:
+    def render(self, prompt: str, tool_name: str | None = None) -> list[tuple[str, str]]:
+        if tool_name is not None and "/" in tool_name:
+            cat, rest = tool_name.split("/", 1)
+            before = "shark "
+            after = " > "
+            return [
+                (PROMPT_STYLE, before),
+                (MODULE_STYLE, cat),
+                ("", "("),
+                (MODULE_STYLE, rest),
+                ("", ")"),
+                ("", after),
+            ]
         if "(" in prompt and ")" in prompt:
             before, rest = prompt.split("(", 1)
             tool_path, after = rest.split(")", 1)
@@ -25,6 +37,6 @@ class PromptRenderer:
                 ("", "("),
                 (MODULE_STYLE, tool_path),
                 ("", ")"),
-                ("", after),
+                (PROMPT_STYLE, after),
             ]
         return [(PROMPT_STYLE, prompt)]

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/console/repl.py

@@ -31,7 +31,7 @@ class _SharkitHistory(History):
         super().__init__()
 
     def load_history_strings(self) -> list[str]:
-        return self._manager.get_history()
+        return list(reversed(self._manager.get_history()))
 
     def store_string(self, string: str) -> None:
         self._manager.add_command(string)
@@ -108,7 +108,7 @@ class Console:
             prompt = self._prompt_renderer.tool_prompt(self._current_tool)
         else:
             prompt = self._prompt_renderer.default_prompt()
-        return self._prompt_renderer.render(prompt)
+        return self._prompt_renderer.render(prompt, tool_name=self._current_tool)
 
     def _init_session(self) -> None:
         self._prompt_renderer = PromptRenderer()
@@ -144,8 +144,6 @@ class Console:
             if not stripped:
                 continue
 
-            if not line[:1].isspace():
-                self._history_manager.add_command(stripped)
             self._session_data["history"] = self._history_manager.get_history()
 
             if not self.process_command(stripped):

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/exceptions.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class SharkitError(Exception):
     def __init__(self, message: str) -> None:
         super().__init__(message)

{sharkit-0.2.1.dev5 → sharkit-1.0.0.dev2}/src/sharkit/history/manager.py

@@ -6,11 +6,13 @@ from pathlib import Path
 from sharkit.config.paths import get_history_file
 from sharkit.exceptions import ConfigurationError
 
-_SENSITIVE_PATTERNS = re.compile(
-    r"(password|passwd|token|api[_-]?key|secret|auth|credential)",
+_SENSITIVE_RE = re.compile(
+    r"\b(password|passwd|token|api[_-]?key|secret|auth_token|credential)\b",
     re.IGNORECASE,
 )
 
+MAX_HISTORY = 10_000
+
 
 class HistoryManager:
     _history_file: Path
@@ -46,7 +48,7 @@ class HistoryManager:
             raise ConfigurationError(f"Failed to write history file: {exc}") from exc
 
     def _is_sensitive(self, command: str) -> bool:
-        return bool(_SENSITIVE_PATTERNS.search(command))
+        return bool(_SENSITIVE_RE.search(command))
 
     def add_command(self, command: str) -> None:
         if command[:1].isspace():
@@ -60,6 +62,8 @@ class HistoryManager:
         if lines and lines[-1] == stripped:
             return
         lines.append(stripped)
+        if len(lines) > MAX_HISTORY:
+            lines = lines[-MAX_HISTORY:]
         self._write_lines(lines)
 
     def get_history(self, limit: int = 100) -> list[str]:
@@ -74,10 +78,21 @@ class HistoryManager:
                 commands.append(line)
         return commands[-limit:]
 
-    def search(self, query: str) -> list[str]:
+    def search(self, query: str, limit: int = 50) -> list[str]:
         lines = self._read_lines()
         query_lower = query.lower()
-        return [line for line in lines if query_lower in line.lower()]
+        results = []
+        for line in reversed(lines):
+            if not line:
+                continue
+            if line.startswith("#"):
+                continue
+            display = line[1:] if line.startswith("+") else line
+            if query_lower in display.lower():
+                results.append(display)
+            if len(results) >= limit:
+                break
+        return results
 
     def clear(self) -> None:
         self._write_lines([])