{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"shell-gpt","slug":"shell-gpt","name":"Shell GPT","type":"cli","url":"https://github.com/TheR1D/shell_gpt","page_url":"https://unfragile.ai/shell-gpt","categories":["cli-tools"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"shell-gpt__cap_0","uri":"capability://code.generation.editing.os.aware.shell.command.generation.with.interactive.execution","name":"os-aware shell command generation with interactive execution","description":"Generates platform-specific shell commands by detecting the user's OS and active shell ($SHELL environment variable), then presents an interactive prompt allowing execution, description, or abortion of the generated command. The DefaultHandler routes the --shell flag to a SHELL SystemRole that constrains LLM output to executable commands. After generation, sgpt parses the response and offers [E]xecute, [D]escribe, [A]bort options, with --no-interaction flag enabling pipeline-friendly non-interactive mode that writes directly to stdout.","intents":["Generate a shell command without leaving the terminal or searching online","Get platform-specific commands that work on my OS (Linux/macOS/Windows)","Execute a generated command directly or review it first before running","Pipe generated commands into other tools without interactive prompts"],"best_for":["DevOps engineers and system administrators automating repetitive tasks","Solo developers reducing context-switching between terminal and documentation","Teams building shell-based CI/CD pipelines that need inline command generation"],"limitations":["No validation of generated commands before execution — dangerous commands can be run if user selects [E]","Platform detection relies on environment variables; may fail in containerized/sandboxed environments without proper $SHELL setup","Interactive mode blocks pipeline usage unless --no-interaction flag is explicitly set","LLM hallucination risk — generated commands may be syntactically valid but semantically incorrect"],"requires":["Python 3.10+","OpenAI API key (OPENAI_API_KEY env var) or configured LiteLLM backend","Bash, Zsh, PowerShell, CMD, Fish, or compatible shell","Network access to OpenAI API or local Ollama/compatible server"],"input_types":["natural language text prompt describing desired shell operation"],"output_types":["executable shell command string","command execution result (stdout/stderr if [E]xecute selected)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_1","uri":"capability://text.generation.language.role.based.prompt.templating.with.system.context.injection","name":"role-based prompt templating with system context injection","description":"Implements a SystemRole abstraction (defined in sgpt/role.py) that wraps user prompts with role-specific system instructions before sending to the LLM. Built-in roles include SHELL (command generation), DESCRIBE_SHELL (command explanation), CODE (code generation), and GENERAL (Q&A). Roles are selected via CLI flags (--shell, --describe-shell, --code) and mapped through DefaultRoles.check_get() in app.py. Custom roles can be created and persisted via --create-role, allowing users to define domain-specific prompt templates that are reused across sessions.","intents":["Generate shell commands, code, or documentation using different specialized prompts","Create custom roles for domain-specific tasks (e.g., SQL query generation, Kubernetes manifests)","Reuse role definitions across multiple invocations without retyping system instructions","Switch between different LLM behaviors (code vs. explanation) via simple CLI flags"],"best_for":["Teams with standardized prompt templates for recurring tasks","Individual developers building personal productivity workflows with custom roles","Organizations needing consistent LLM behavior across different use cases"],"limitations":["Role system is stateless — no learning or adaptation across sessions; each invocation uses the same template","Custom roles stored in ~/.config/shell_gpt/ as plain text; no versioning or role rollback mechanism","No role composition or inheritance — each role is independent, leading to template duplication","Role selection is CLI-flag based; no fuzzy matching or role discovery UI"],"requires":["Python 3.10+","Write access to ~/.config/shell_gpt/ directory for custom role storage","Understanding of LLM prompt engineering to create effective custom roles"],"input_types":["user prompt text","role identifier (via --shell, --code, --role flag or custom role name)"],"output_types":["LLM response constrained by role's system instructions","role definition (when using --create-role)"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_10","uri":"capability://text.generation.language.editor.based.prompt.input.with.multi.line.support","name":"editor-based prompt input with multi-line support","description":"Allows users to compose prompts in their preferred text editor via the --editor flag, which opens $EDITOR (or a configured editor) for prompt composition. This is useful for long, complex prompts that are cumbersome to type on the command line. The editor integration is implemented in sgpt/utils.py and captures the editor's output as the prompt text. After the user saves and closes the editor, the prompt is sent to the LLM. This enables multi-line prompts, code snippets, and formatted text without shell escaping.","intents":["Compose long or complex prompts in a text editor","Include code snippets or formatted text in prompts without shell escaping","Use familiar editor keybindings and features (syntax highlighting, etc.) for prompt composition","Paste multi-line content into prompts easily"],"best_for":["Users composing complex prompts with code snippets or formatted text","Teams using sgpt for documentation or content generation","Developers who prefer editor-based workflows"],"limitations":["Requires $EDITOR environment variable to be set; fails if no editor is configured","Adds latency because the editor must be launched and closed before the prompt is sent","No syntax highlighting or validation specific to prompts — editor treats it as plain text","Editor choice is global ($EDITOR); no per-invocation editor selection"],"requires":["Python 3.10+","$EDITOR environment variable set to a valid editor (vim, nano, emacs, etc.)","OpenAI API key or configured LiteLLM backend"],"input_types":["text composed in the editor (multi-line, formatted)"],"output_types":["LLM response to the editor-composed prompt"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_11","uri":"capability://automation.workflow.configuration.management.with.file.based.settings","name":"configuration management with file-based settings","description":"Manages tool configuration via ~/.config/shell_gpt/.sgptrc, a file-based configuration store that persists settings across invocations. Configuration includes API keys, backend selection (USE_LITELLM), model choice, cache TTL, and custom roles. The config.py module handles reading and writing configuration, with sensible defaults for unset values. On first run, sgpt prompts the user for an OpenAI API key and writes it to .sgptrc. Configuration can also be overridden via environment variables (e.g., OPENAI_API_KEY, API_BASE_URL), allowing both file-based and environment-based configuration.","intents":["Persist API keys and settings across terminal sessions","Configure sgpt for different environments (local, cloud, enterprise)","Override configuration via environment variables for CI/CD pipelines","Store custom roles and other user-defined settings"],"best_for":["Individual developers setting up sgpt on their machine","Teams deploying sgpt in CI/CD pipelines with environment-based configuration","Organizations using custom roles or non-default LLM providers"],"limitations":["Configuration file is stored in plaintext; API keys are not encrypted","No configuration versioning or rollback mechanism","Configuration is machine-local; no cloud sync or team sharing","No validation of configuration values; invalid settings may cause runtime errors","Environment variable overrides are not documented in the config file; users must remember which env vars are supported"],"requires":["Python 3.10+","Write access to ~/.config/shell_gpt/ directory","OpenAI API key (for default configuration) or environment variables for custom providers"],"input_types":["configuration file (~/.config/shell_gpt/.sgptrc)","environment variables (OPENAI_API_KEY, API_BASE_URL, USE_LITELLM, etc.)"],"output_types":["parsed configuration dictionary","written configuration file"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_2","uri":"capability://tool.use.integration.multi.backend.llm.routing.with.provider.abstraction","name":"multi-backend llm routing with provider abstraction","description":"Abstracts LLM provider selection through a Handler base class (sgpt/handlers/handler.py) that supports OpenAI (default), Azure OpenAI, and OpenAI-compatible servers (Ollama, local models) via LiteLLM. Backend selection is controlled by the USE_LITELLM config flag in ~/.config/shell_gpt/.sgptrc and environment variables (API_BASE_URL, OPENAI_API_KEY). The Handler class owns client initialization, request routing, and response streaming, allowing providers to be swapped without changing CLI or role logic. LiteLLM is an optional dependency; if not installed, the tool falls back to OpenAI's official client.","intents":["Use OpenAI's GPT-4o by default without configuration","Switch to local models (Ollama) for privacy or cost savings","Route requests through Azure OpenAI for enterprise deployments","Support multiple LLM providers without rebuilding or redeploying the tool"],"best_for":["Organizations with existing Azure OpenAI or Ollama infrastructure","Privacy-conscious teams running local LLMs to avoid cloud API calls","Developers building multi-provider LLM applications that need consistent interfaces"],"limitations":["LiteLLM is optional; users must explicitly install it to use non-OpenAI providers (pip install shell-gpt[litellm])","No built-in provider failover or load balancing — if primary provider is down, requests fail","Provider-specific features (e.g., vision, function calling) are not abstracted; users must know which providers support which features","Configuration is file-based (~/.config/shell_gpt/.sgptrc); no runtime provider switching without editing config"],"requires":["Python 3.10+","OpenAI API key (OPENAI_API_KEY env var) for default provider","LiteLLM optional dependency (pip install shell-gpt[litellm]) for non-OpenAI providers","API_BASE_URL environment variable for custom/local providers","Network access to chosen LLM provider (OpenAI, Azure, Ollama, etc.)"],"input_types":["prompt text","configuration flags (USE_LITELLM, API_BASE_URL, OPENAI_API_KEY)"],"output_types":["LLM response (text, streamed or buffered)","error messages if provider is unreachable"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_3","uri":"capability://memory.knowledge.persistent.chat.sessions.with.conversation.history","name":"persistent chat sessions with conversation history","description":"Maintains multi-turn conversations using the --chat <id> flag, which routes requests to ChatHandler instead of DefaultHandler. Chat sessions are persisted to disk (location managed by sgpt/cache.py) with full conversation history, allowing users to reference previous messages and build context across multiple invocations. Each session is identified by a unique ID; the same ID can be reused to continue a conversation. Session state includes all prior user prompts and LLM responses, enabling the LLM to maintain context without re-sending the entire history on each request (handled by the Handler's context management).","intents":["Have multi-turn conversations with the LLM without losing context between terminal sessions","Reference previous messages in the same conversation (e.g., 'explain the command from step 3')","Maintain separate conversations for different projects or topics using different session IDs","Review conversation history after closing the terminal"],"best_for":["Developers debugging complex issues that require back-and-forth explanation","Teams collaborating on problems where chat history serves as documentation","Users building iterative workflows (e.g., refining code across multiple prompts)"],"limitations":["Chat history is stored locally in ~/.config/shell_gpt/; no cloud sync or multi-device access","No built-in conversation search or indexing — finding old messages requires manual review","Session IDs are user-provided strings; no automatic session naming or discovery UI","Context window is bounded by the LLM's token limit; very long conversations may be truncated","No conversation branching or version control — overwriting a session ID loses prior history"],"requires":["Python 3.10+","Write access to ~/.config/shell_gpt/ for session persistence","OpenAI API key or configured LiteLLM backend","Unique session ID (user-provided string, e.g., 'debug-session-1')"],"input_types":["natural language prompt text","session ID (string identifier for conversation)"],"output_types":["LLM response with full conversation context","persisted conversation history (stored on disk)"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_4","uri":"capability://text.generation.language.interactive.repl.mode.with.stateful.command.loops","name":"interactive repl mode with stateful command loops","description":"Provides a read-eval-print loop (REPL) via the --repl <id> flag, which routes requests to ReplHandler and creates an interactive shell-like environment where users can issue multiple prompts in sequence without restarting the tool. Each REPL session maintains state (conversation history, role context) across multiple user inputs, similar to chat sessions but with a continuous interactive loop. The REPL mode is useful for exploratory tasks where users want rapid iteration without the overhead of invoking sgpt multiple times.","intents":["Iterate rapidly on prompts without restarting the tool for each request","Maintain conversation context across multiple interactive inputs","Explore ideas or debug issues in a continuous session","Use sgpt as an interactive assistant within a single terminal session"],"best_for":["Developers exploring APIs or debugging issues interactively","Users learning new tools or languages who want rapid feedback loops","Teams using sgpt as an interactive pair-programming assistant"],"limitations":["REPL mode is terminal-based; no GUI or rich text formatting","Session state is in-memory during REPL execution; exiting the REPL loses unsaved context","No built-in command history or readline-style editing (depends on terminal emulator)","REPL sessions are not automatically persisted like --chat sessions; history is lost on exit unless explicitly saved","No multi-user or concurrent REPL sessions — one REPL per terminal"],"requires":["Python 3.10+","OpenAI API key or configured LiteLLM backend","Interactive terminal (TTY) for input/output","Session ID (user-provided string)"],"input_types":["natural language prompts entered interactively at the REPL prompt"],"output_types":["LLM responses printed to terminal","in-memory conversation history (not persisted by default)"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_5","uri":"capability://memory.knowledge.response.caching.with.configurable.ttl","name":"response caching with configurable ttl","description":"Caches LLM responses to disk using sgpt/cache.py, reducing API calls and latency for repeated or similar prompts. Caching is enabled by default (--cache flag) and uses a hash of the prompt, role, and other parameters as the cache key. Cached responses are stored in ~/.config/shell_gpt/ with configurable time-to-live (TTL); expired cache entries are automatically invalidated. The cache is transparent to users — if a cached response exists, it is returned without making an API call. Cache behavior can be controlled via configuration flags.","intents":["Reduce API costs by reusing responses for identical or similar prompts","Speed up repeated queries by serving cached responses instantly","Work offline if cached responses are available","Disable caching for sensitive queries or when fresh responses are required"],"best_for":["Cost-conscious teams running sgpt frequently with overlapping queries","Developers testing workflows where the same prompts are issued multiple times","Users in low-bandwidth environments who want to minimize API calls"],"limitations":["Cache key is based on prompt hash; semantically similar but textually different prompts are not deduplicated","No cache invalidation mechanism other than TTL expiration — stale responses may be served if the LLM's knowledge has been updated","Cache is local to the machine; no shared cache across team members or devices","Cache storage is unencrypted in ~/.config/shell_gpt/; sensitive responses are stored in plaintext","No cache statistics or visibility into what is cached — users cannot easily inspect or manage cache contents"],"requires":["Python 3.10+","Write access to ~/.config/shell_gpt/ for cache storage","Sufficient disk space for cached responses (typically small, but scales with usage)"],"input_types":["prompt text","role and configuration parameters"],"output_types":["cached LLM response (if cache hit)","fresh LLM response (if cache miss or expired)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_6","uri":"capability://tool.use.integration.llm.function.calling.with.schema.based.tool.registry","name":"llm function calling with schema-based tool registry","description":"Enables the LLM to call external functions via a schema-based function registry (sgpt/function.py and sgpt/llm_functions/). Functions are defined with JSON schemas that describe their parameters and return types, and the LLM can invoke them as part of its response generation. The function calling system integrates with the Handler base class, which detects function calls in LLM responses, executes the corresponding functions, and feeds results back to the LLM for further processing. Built-in functions are provided in sgpt/llm_functions/ (e.g., shell command execution, file operations), and custom functions can be registered.","intents":["Allow the LLM to execute shell commands or access external tools as part of its reasoning","Build agents that can take actions (e.g., run code, fetch data) based on LLM decisions","Extend sgpt with custom functions for domain-specific tasks","Enable the LLM to verify its outputs by executing them (e.g., test generated code)"],"best_for":["Developers building LLM agents that need to take actions beyond text generation","Teams automating complex workflows where the LLM must interact with external systems","Advanced users extending sgpt with custom tools and integrations"],"limitations":["Function calling is LLM-dependent; not all models support function calling (e.g., older OpenAI models, some open-source models)","Schema definition is manual; no automatic schema generation from Python function signatures","No built-in error handling or retry logic for failed function calls — errors are passed back to the LLM","Function execution is synchronous; long-running functions block the LLM's response generation","No sandboxing or security isolation for function execution — malicious functions can access the entire system"],"requires":["Python 3.10+","LLM model that supports function calling (OpenAI GPT-4, Claude, etc.)","JSON schema definitions for custom functions","Appropriate permissions for functions to execute (e.g., shell access, file system access)"],"input_types":["prompt text","function schema definitions (JSON)"],"output_types":["LLM response with function calls","function execution results","final LLM response after function execution"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_7","uri":"capability://automation.workflow.shell.integration.with.hotkey.based.invocation","name":"shell integration with hotkey-based invocation","description":"Provides shell hotkey integration via the --install-integration flag, which installs shell-specific keybindings (e.g., Ctrl+L in Bash/Zsh) that invoke sgpt with the current command line as the prompt. The integration is implemented in sgpt/integration.py and sgpt/utils.py and modifies shell configuration files (~/.bashrc, ~/.zshrc, etc.) to add the hotkey binding. When the hotkey is pressed, the current command line is captured, sent to sgpt, and the response is inserted back into the shell prompt for review or execution. This enables users to invoke sgpt without leaving the shell or typing the sgpt command.","intents":["Invoke sgpt with a hotkey without typing the sgpt command","Use sgpt to explain or refine a command that's already typed in the shell","Integrate sgpt into the shell workflow without context-switching","Install sgpt integration automatically without manual shell configuration"],"best_for":["Power users who want seamless shell integration and rapid access to sgpt","Teams standardizing on sgpt as a shell productivity tool","Developers who frequently need to look up or refine commands"],"limitations":["Integration is shell-specific; different shells (Bash, Zsh, Fish, PowerShell) require different implementations","Installation modifies shell configuration files (~/.bashrc, ~/.zshrc); users must reload the shell or source the config manually","Hotkey bindings may conflict with existing shell keybindings or terminal emulator shortcuts","No uninstall mechanism; removing integration requires manual editing of shell config files","Integration is not portable across machines; each machine requires separate installation"],"requires":["Python 3.10+","Supported shell (Bash, Zsh, Fish, PowerShell, etc.)","Write access to shell configuration files (~/.bashrc, ~/.zshrc, etc.)","Terminal emulator that supports custom keybindings"],"input_types":["current shell command line (captured via hotkey)"],"output_types":["sgpt response inserted into shell prompt","modified shell configuration file with hotkey binding"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_8","uri":"capability://code.generation.editing.code.generation.with.syntax.aware.output.formatting","name":"code generation with syntax-aware output formatting","description":"Generates code snippets via the --code flag, which routes requests to the CODE SystemRole and disables markdown formatting in the response. The CODE role constrains the LLM to generate clean, executable code without explanatory text or markdown code blocks. Output is formatted as raw code suitable for piping to files or other tools (e.g., sgpt --code 'generate a Python function' > script.py). The Handler base class manages response streaming and formatting, ensuring that code output is not wrapped in markdown or other decorations.","intents":["Generate code snippets in a specific language without markdown formatting","Pipe generated code directly to files or other tools","Get clean, executable code without explanatory text","Generate code for multiple languages (Python, JavaScript, SQL, etc.)"],"best_for":["Developers generating boilerplate or utility code quickly","Teams automating code generation as part of CI/CD pipelines","Users piping generated code to files or linters without manual cleanup"],"limitations":["No syntax validation or linting of generated code — output may be syntactically invalid","No language-specific formatting or style enforcement — generated code may not match project conventions","LLM may generate incomplete code or omit imports/dependencies","No support for multi-file code generation — each invocation generates a single code snippet","Code generation quality depends on prompt clarity; vague prompts produce poor results"],"requires":["Python 3.10+","OpenAI API key or configured LiteLLM backend","Clear, language-specific prompt describing the desired code"],"input_types":["natural language prompt describing the code to generate","optional context (e.g., function signature, requirements)"],"output_types":["raw code snippet (no markdown formatting)","code suitable for piping to files or tools"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__cap_9","uri":"capability://text.generation.language.shell.command.description.and.explanation","name":"shell command description and explanation","description":"Explains shell commands via the --describe-shell flag, which routes requests to the DESCRIBE_SHELL SystemRole. This role constrains the LLM to provide clear, human-readable explanations of shell commands, breaking down syntax, flags, and behavior. Users can pass an existing command (e.g., sgpt --describe-shell 'find . -type f -name \"*.json\"') and receive a detailed explanation. This is useful for understanding unfamiliar commands or documenting complex shell scripts.","intents":["Understand what a shell command does without consulting man pages","Explain complex shell syntax to team members","Document shell scripts by generating explanations for each command","Learn shell commands interactively"],"best_for":["Developers learning shell scripting or unfamiliar with Unix tools","Teams documenting shell-based infrastructure or CI/CD pipelines","Users who prefer natural language explanations over man pages"],"limitations":["Explanations are LLM-generated and may be inaccurate or incomplete for obscure commands","No support for multi-line shell scripts — each invocation explains a single command","Explanations are generic; they don't account for project-specific context or custom aliases","No interactive drill-down; users cannot ask follow-up questions about specific parts of the explanation"],"requires":["Python 3.10+","OpenAI API key or configured LiteLLM backend","Shell command to explain (passed as a string argument)"],"input_types":["shell command string"],"output_types":["natural language explanation of the command"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"shell-gpt__headline","uri":"capability://tool.use.integration.ai.powered.command.line.productivity.tool","name":"ai-powered command-line productivity tool","description":"Shell GPT is an AI-driven command-line tool that generates shell commands, code snippets, and documentation directly in your terminal, streamlining your workflow without leaving the command line.","intents":["best AI command-line tool","command-line tool for generating shell commands","AI tool for terminal productivity","CLI tool for code generation","best AI tool for developers"],"best_for":["developers","system administrators"],"limitations":["requires terminal access","depends on LLM backend"],"requires":["Python 3.10 or higher"],"input_types":["text prompts"],"output_types":["shell commands","code snippets","documentation"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":70,"verified":false,"data_access_risk":"high","permissions":["Python 3.10+","OpenAI API key (OPENAI_API_KEY env var) or configured LiteLLM backend","Bash, Zsh, PowerShell, CMD, Fish, or compatible shell","Network access to OpenAI API or local Ollama/compatible server","Write access to ~/.config/shell_gpt/ directory for custom role storage","Understanding of LLM prompt engineering to create effective custom roles","$EDITOR environment variable set to a valid editor (vim, nano, emacs, etc.)","OpenAI API key or configured LiteLLM backend","Write access to ~/.config/shell_gpt/ directory","OpenAI API key (for default configuration) or environment variables for custom providers"],"failure_modes":["No validation of generated commands before execution — dangerous commands can be run if user selects [E]","Platform detection relies on environment variables; may fail in containerized/sandboxed environments without proper $SHELL setup","Interactive mode blocks pipeline usage unless --no-interaction flag is explicitly set","LLM hallucination risk — generated commands may be syntactically valid but semantically incorrect","Role system is stateless — no learning or adaptation across sessions; each invocation uses the same template","Custom roles stored in ~/.config/shell_gpt/ as plain text; no versioning or role rollback mechanism","No role composition or inheritance — each role is independent, leading to template duplication","Role selection is CLI-flag based; no fuzzy matching or role discovery UI","Requires $EDITOR environment variable to be set; fails if no editor is configured","Adds latency because the editor must be launched and closed before the prompt is sent","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:05.296Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=shell-gpt","compare_url":"https://unfragile.ai/compare?artifact=shell-gpt"}},"signature":"1ePkHSJoDNvbz9QE735hwgDg5zgz7x35e6jXKNNll0Ty+0x0Gif6zctPXDWlHlzE/qQcJRazeXxxOIo9XWXbBQ==","signedAt":"2026-06-22T11:46:48.798Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/shell-gpt","artifact":"https://unfragile.ai/shell-gpt","verify":"https://unfragile.ai/api/v1/verify?slug=shell-gpt","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}