# Where to Find the Command Object in thefuck: Complete Guide to the Core Data Model

> Locate the Command object definition in thefuck types.py. Understand its role in encapsulating shell commands output and arguments for rule processing.

- Repository: [Vladimir Iakovlev/thefuck](https://github.com/nvbn/thefuck)
- Tags: internals
- Published: 2026-02-27

---

**The `Command` object in thefuck is defined in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) (lines 12‑66) and serves as the central data structure that encapsulates the original shell command, its captured output, and parsed arguments for the rule engine.**

The `Command` object is the foundational data model in **nvbn/thefuck**, the popular Python utility that corrects mistyped console commands. Located in the repository’s type definitions, this class bridges raw shell input and the intelligent correction pipeline, making it essential for developers extending the tool or debugging rule behavior.

## Location of the Command Class in thefuck

### thefuck/types.py: The Core Definition

The canonical definition of the `Command` class resides in **[`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py)** between lines 12 and 66. This file houses the primary data structures used throughout the application, including `Rule` and `CorrectedCommand`.

The class is implemented as a Python class with the following key characteristics:

- **Immutable-style design**: While not strictly immutable, it provides an `update()` method that returns new instances rather than modifying state in place.
- **Rich properties**: Beyond basic `script` and `output` attributes, it exposes `script_parts` (the tokenized command), and legacy accessors for `stdout` and `stderr`.
- **Equality and representation**: Full `__eq__`, `__hash__`, and `__repr__` implementations enable easy debugging and testing.

## How to Create a Command Object in thefuck

### Direct Instantiation with Command(script, output)

For internal testing or when you already have the command string and its captured output, instantiate the class directly:

```python
from thefuck.types import Command

cmd = Command("git status", "fatal: not a git repository...")

```

This constructor stores the raw `script` string and the `output` (typically combined stdout and stderr from the failed command).

### Using from_raw_script() for Shell Input

When integrating with the shell hook, use the **`from_raw_script()`** class method defined at lines 67‑83 in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py). This factory method handles the heavy lifting of shell integration:

```python
from thefuck.types import Command

raw_script = ["git", "st"]  # As provided by the shell parser

cmd = Command.from_raw_script(raw_script)

```

Under the hood, this method:
1. Formats the raw script fragments into a single command string
2. Expands shell shortcuts and aliases via `thefuck.utils.format_raw_script`
3. Executes the command to capture its output
4. Returns a fully populated `Command` instance

## Command Object Properties and Methods

The `Command` class exposes several attributes critical for rule development:

- **`script`** (**str**): The complete command line as executed (e.g., `"git status"`).
- **`output`** (**str**): The captured output from the command execution, typically combining stdout and stderr.
- **`script_parts`** (**list**): The tokenized command split into parts (e.g., `['git', 'status']`), useful for parsing subcommands and arguments.
- **`stdout` / `stderr`** (**str**): Legacy properties that now return the combined `output` with deprecation warnings.

Key methods include:

- **`update(script=None, output=None)`**: Returns a new `Command` instance with updated fields, supporting immutable-style modifications.
- **`__repr__`**: Provides a debug-friendly string representation showing `script` and `output`.

## Architectural Role of the Command Object

The `Command` object functions as the **universal input** to thefuck's rule engine. Every rule in `thefuck/rules/` receives a `Command` instance through two primary interfaces:

1. **`Rule.is_match(command)`**: Determines whether the rule applies to the given command based on `script`, `script_parts`, or `output`.
2. **`Rule.get_corrected_commands(command)`**: Generates one or more `CorrectedCommand` objects proposing fixes.

This design decouples shell interaction from correction logic. The `Command` object normalizes raw shell input—handling aliases, environment variables, and output capture—into a consistent interface that rules can inspect without worrying about shell-specific parsing.

## Code Examples: Working with Command Objects

### Creating a Command Manually

```python
from thefuck.types import Command

# Simulate a failed git command

script = "git status"
output = "fatal: not a git repository (or any of the parent directories): .git"

cmd = Command(script, output)

print(cmd)                       # Command(script=git status, output=...)

print(cmd.script_parts)          # ['git', 'status']

```

### Using from_raw_script for Shell Integration

```python
from thefuck.types import Command

# Raw fragments as parsed by the shell

raw_script = ["git", "st"]
cmd = Command.from_raw_script(raw_script)

# Contains expanded command and captured output

print(cmd.script)                 # "git status"

print(cmd.output)                 # Captured stderr/stdout

```

### Feeding Commands to Rules

```python
from thefuck.types import Command
from thefuck.rules.git_add import match, get_new_command

cmd = Command("git add", "fatal: pathspec '.' did not match any files")
if match(cmd):
    suggestion = get_new_command(cmd)
    print(suggestion)              # "git add ."

```

### Immutable Updates

```python
new_cmd = cmd.update(script="git add .", output="")
print(new_cmd.script)              # "git add ."

```

## Related Files in thefuck

Understanding the `Command` object requires familiarity with several related modules:

| File | Purpose |
|------|---------|
| [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) | Defines `Command`, `Rule`, and `CorrectedCommand` classes. |
| [`thefuck/utils.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/utils.py) | Contains `format_raw_script` helper used by `Command.from_raw_script`. |
| [`thefuck/shells/__init__.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/shells/__init__.py) | Shell abstraction layer for command splitting and alias expansion. |
| `thefuck/rules/*` | Rule implementations that consume `Command` objects via `is_match` and `get_corrected_commands`. |
| [`thefuck/conf.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/conf.py) | Configuration settings affecting command handling and rule loading. |

## Summary

- The `Command` class is defined in **[`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py)** (lines 12‑66) and represents the central data model for shell commands.
- Instantiate directly with `Command(script, output)` for testing, or use **`Command.from_raw_script()`** (lines 67‑83) to handle shell-provided input with automatic expansion and output capture.
- Key properties include **`script`**, **`output`**, and **`script_parts`**, which rules use to analyze and correct failed commands.
- The `Command` object acts as the universal input to the rule engine, decoupling shell-specific parsing from correction logic.

## Frequently Asked Questions

### Where is the Command object defined in thefuck?

The `Command` object is defined in the file **[`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py)** between lines 12 and 66. This module serves as the repository's central type definitions file, also housing the `Rule` and `CorrectedCommand` classes that work alongside `Command` in the correction pipeline.

### What is the difference between Command() and Command.from_raw_script()?

**`Command(script, output)`** is the direct constructor that accepts a formatted command string and its captured output, primarily used for unit testing or internal rule processing. **`Command.from_raw_script(raw_script)`** is a classmethod (lines 67‑83) designed for shell integration—it receives raw command fragments, expands aliases, executes the command to capture output, and returns a fully populated instance.

### How does the Command object interact with thefuck rules?

Every rule in thefuck receives a `Command` instance through its **`is_match(command)`** method to determine applicability and **`get_corrected_commands(command)`** to generate fixes. Rules inspect `command.script`, `command.script_parts`, and `command.output` to analyze the failure and construct appropriate corrections, making `Command` the universal interface between the shell and the rule engine.

### What properties does the Command object expose for debugging?

The `Command` object exposes **`script`** (the full command string), **`output`** (combined stdout/stderr), and **`script_parts`** (tokenized command list). It also provides legacy **`stdout`** and **`stderr`** properties that return the combined output with deprecation warnings, plus a helpful **`__repr__`** method for debug output showing both script and output contents.