# @fragment-dev/cli

[Fragment](https://fragment.dev) is the Ledger API for engineers that move money. Stop wrangling payment tables, debugging balance errors and hacking together data pipelines. Start shipping the features that make a difference.

# Commands

<!-- commands -->
* [`fragment add-ledger-entry`](#fragment-add-ledger-entry)
* [`fragment autocomplete [SHELL]`](#fragment-autocomplete-shell)
* [`fragment commands`](#fragment-commands)
* [`fragment create-custom-link`](#fragment-create-custom-link)
* [`fragment create-ledger`](#fragment-create-ledger)
* [`fragment delete-custom-txs`](#fragment-delete-custom-txs)
* [`fragment delete-ledger`](#fragment-delete-ledger)
* [`fragment delete-schema`](#fragment-delete-schema)
* [`fragment designer-mcp`](#fragment-designer-mcp)
* [`fragment gen-graphql`](#fragment-gen-graphql)
* [`fragment get-schema`](#fragment-get-schema)
* [`fragment help [COMMAND]`](#fragment-help-command)
* [`fragment init`](#fragment-init)
* [`fragment login`](#fragment-login)
* [`fragment migrate-ledger-entry`](#fragment-migrate-ledger-entry)
* [`fragment query ledgerAccounts`](#fragment-query-ledgeraccounts)
* [`fragment query ledgers`](#fragment-query-ledgers)
* [`fragment query schema`](#fragment-query-schema)
* [`fragment query schemas`](#fragment-query-schemas)
* [`fragment reverse-ledger-entry`](#fragment-reverse-ledger-entry)
* [`fragment start`](#fragment-start)
* [`fragment store-schema`](#fragment-store-schema)
* [`fragment token`](#fragment-token)
* [`fragment update`](#fragment-update)
* [`fragment update-ledger-account`](#fragment-update-ledger-account)
* [`fragment verify-schema`](#fragment-verify-schema)
* [`fragment workspace`](#fragment-workspace)

## `fragment add-ledger-entry`

Add a Ledger Entry to a Ledger Account.

```
USAGE
  $ fragment add-ledger-entry -i <value> -l <value> -t <value> [-v] [-n <value>] [-p <value>...]

FLAGS
  -i, --ik=<value>            (required) The Idempotency Key for Ledger Entry creation.
  -l, --ledger.ik=<value>     (required) The Idempotency Key of the Ledger to post the Ledger Entry to.
  -n, --type.version=<value>  The version of the Ledger Entry type you want to post.
  -p, --param=<value>...      The parameters for your Ledger Entry. (ex: --param amount=100 --param currency=USD)
  -t, --type=<value>          (required) The `type` of Ledger Entry you want to post.
  -v, --verbose               Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Add a Ledger Entry to a Ledger Account.

  This mirrors the addLedgerEntry mutation in the GraphQL API.

  Only entries with type are allowed to be posted to a Ledger Account.


EXAMPLES
  $ fragment add-ledger-entry

FLAG DESCRIPTIONS
  -p, --param=<value>...  The parameters for your Ledger Entry. (ex: --param amount=100 --param currency=USD)

    You may specify multiple parameters by repeating the flag.
```

## `fragment autocomplete [SHELL]`

Display autocomplete installation instructions.

```
USAGE
  $ fragment autocomplete [SHELL] [-r]

ARGUMENTS
  [SHELL]  (zsh|bash|powershell) Shell type

FLAGS
  -r, --refresh-cache  Refresh cache (ignores displaying instructions)

DESCRIPTION
  Display autocomplete installation instructions.

EXAMPLES
  $ fragment autocomplete

  $ fragment autocomplete bash

  $ fragment autocomplete zsh

  $ fragment autocomplete powershell

  $ fragment autocomplete --refresh-cache
```

_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v3.2.50/src/commands/autocomplete/index.ts)_

## `fragment commands`

List all fragment commands.

```
USAGE
  $ fragment commands [--json] [-c id|plugin|summary|type... | --tree] [--deprecated] [-x | ] [--hidden]
    [--no-truncate | ] [--sort id|plugin|summary|type | ]

FLAGS
  -c, --columns=<option>...  Only show provided columns (comma-separated).
                             <options: id|plugin|summary|type>
  -x, --extended             Show extra columns.
      --deprecated           Show deprecated commands.
      --hidden               Show hidden commands.
      --no-truncate          Do not truncate output.
      --sort=<option>        [default: id] Property to sort by.
                             <options: id|plugin|summary|type>
      --tree                 Show tree of commands.

GLOBAL FLAGS
  --json  Format output as json.

DESCRIPTION
  List all fragment commands.
```

_See code: [@oclif/plugin-commands](https://github.com/oclif/plugin-commands/blob/4.1.57/src/commands/commands.ts)_

## `fragment create-custom-link`

Create a Custom Link

```
USAGE
  $ fragment create-custom-link -i <value> --name <value> [-v]

FLAGS
  -i, --ik=<value>    (required) The Idempotency Key for the Custom Link creation.
  -v, --verbose       Enable verbose mode (prints GraphQL commands).
      --name=<value>  (required) The name for the Custom Link.

DESCRIPTION
  Create a Custom Link

  This mirrors the CreateCustomLink API endpoint.
  Read https://fragment.dev/docs/sync-payments#custom-link-onboarding to learn more about Custom Links.

EXAMPLES
  $ fragment create-custom-link --ik <ik> --name <name>
```

## `fragment create-ledger`

Create schematized Ledger within your Fragment workspace

```
USAGE
  $ fragment create-ledger -i <value> -n <value> [-v] [-s <value>]

FLAGS
  -i, --ik=<value>      (required) Idempotency key for Ledger creation
  -n, --name=<value>    (required) Ledger name (e.g. 'My First Ledger')
  -s, --schema=<value>  [default: fragment.jsonc] Path to schema file (defaults to fragment.jsonc)
  -v, --verbose         Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Create schematized Ledger within your Fragment workspace

EXAMPLES
  $ fragment create-ledger
```

## `fragment delete-custom-txs`

Delete Custom Txs.

```
USAGE
  $ fragment delete-custom-txs --id <value>... [-v]

FLAGS
  -v, --verbose        Enable verbose mode (prints GraphQL commands).
      --id=<value>...  (required) Fragment ID of the Custom Tx to delete.

DESCRIPTION
  Delete Custom Txs.

  This mirrors the deleteCustomTxs mutation in the GraphQL API.

EXAMPLES
  $ fragment delete-custom-txs
```

## `fragment delete-ledger`

Delete a Ledger.

```
USAGE
  $ fragment delete-ledger [-v] [-l <value>] [--ledger.id <value>]

FLAGS
  -l, --ledger.ik=<value>  The Idempotency Key of the Ledger to delete.
  -v, --verbose            Enable verbose mode (prints GraphQL commands).
      --ledger.id=<value>  The Fragment ID of the Ledger to delete.

DESCRIPTION
  Delete a Ledger.

  This mirrors the deleteLedger mutation in the GraphQL API.

EXAMPLES
  $ fragment delete-ledger
```

## `fragment delete-schema`

Delete a Schema.

```
USAGE
  $ fragment delete-schema -k <value> [-v]

FLAGS
  -k, --key=<value>  (required) Key of the Schema to delete (e.g. template-schema).
  -v, --verbose      Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Delete a Schema.

  This mirrors the deleteSchema mutation in the GraphQL API.

EXAMPLES
  $ fragment delete-schema
```

## `fragment designer-mcp`

Connect your LLM to the Fragment Schema designer (experimental)

```
USAGE
  $ fragment designer-mcp [-p <value>] [--host <value>] [--allowed-origin <value>...]

FLAGS
  -p, --port=<value>               [default: 4321] Port to bind the HTTP server on
      --allowed-origin=<value>...  Additional CORS origin to allow (repeatable). Localhost is always allowed.
      --host=<value>               [default: 127.0.0.1] Host to bind the HTTP server on

DESCRIPTION
  Connect your LLM to the Fragment Schema designer (experimental)

EXAMPLES
  $ fragment designer-mcp

  $ fragment designer-mcp --port 4321

  $ fragment designer-mcp --host 127.0.0.1 --port 5000
```

## `fragment gen-graphql`

Generate GraphQL queries from your Schema for your SDK.

```
USAGE
  $ fragment gen-graphql -p <value> -o <value> [--output-file-per-query] [--include-standard-queries]
    [--include-runtime-args]

FLAGS
  -o, --output=<value>            (required) The output path for the generated file(s). Must end with .graphql or .gql,
                                  unless --output-file-per-query is set. If set, the output path must be a directory.
  -p, --path=<value>              (required) The path to the schema file.
      --include-runtime-args      Include tags, groups, and conditions (when not defined in the Schema) as arguments in
                                  the generated GraphQL queries.
      --include-standard-queries  Include the set of standard queries in the output. This is required only if you are
                                  not using the Fragment SDK.
      --output-file-per-query     Output each query in a separate file instead of a single file.

DESCRIPTION
  Generate GraphQL queries from your Schema for your SDK.

  This command generates a GraphQL query for each entry type in your ledger Schema.
  Use this command with Fragment SDKs to create type-safe code to update your ledger.

EXAMPLES
  Output the GraphQL queries from the schema file at <path>.

    $ fragment gen-graphql --path <path>

  Output the GraphQL queries to a specific output path.

    $ fragment gen-graphql --path <path> --output <output path>

  Output each GraphQL query in a separate file.

    $ fragment gen-graphql --path <path> --output <output path> --output-file-per-query

  Include the standard GraphQL queries and output each in a separate file.

    $ fragment gen-graphql --path <path> --output <output path> --output-file-per-query --include-standard-queries
```

## `fragment get-schema`

Retrieve a schema from the API for local use

```
USAGE
  $ fragment get-schema [-v] [-k <value>] [--version <value>] [-o <value>]

FLAGS
  -k, --key=<value>      Key of schema (e.g. template-schema)
  -o, --output=<value>   Path to the schema file (e.g. /home/user/code/schema.jsonc). Defaults to the current directory
                         and the schema key as the file name.
  -v, --verbose          Enable verbose mode (prints GraphQL commands).
      --version=<value>  Schema version to retrieve (e.g. 2). Defaults to latest available version.

DESCRIPTION
  Retrieve a schema from the API for local use

EXAMPLES
  $ fragment get-schema
```

## `fragment help [COMMAND]`

Display help for fragment.

```
USAGE
  $ fragment help [COMMAND...] [-n]

ARGUMENTS
  [COMMAND...]  Command to show help for.

FLAGS
  -n, --nested-commands  Include all nested commands in the output.

DESCRIPTION
  Display help for fragment.
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/6.2.50/src/commands/help.ts)_

## `fragment init`

Initialize an example chart of accounts locally

```
USAGE
  $ fragment init [-f <value>]

FLAGS
  -f, --file=<value>  [default: fragment.jsonc] Path to write initial schema to

DESCRIPTION
  Initialize an example chart of accounts locally

EXAMPLES
  $ fragment init
```

## `fragment login`

Authenticate with FRAGMENT.

```
USAGE
  $ fragment login [--client-id <value>] [--client-secret <value>] [--api-url <value>] [--oauth-url
    <value>] [--oauth-scope <value>] [--test]

FLAGS
  --api-url=<value>        The API URL for your FRAGMENT Workspace (ex: https://api.us-west-2.fragment.dev/graphql)
  --client-id=<value>      The API Client ID for your FRAGMENT Workspace.
  --client-secret=<value>  The API Client Secret for your FRAGMENT Workspace
  --oauth-scope=<value>    The OAuth Scope for your auth token (ex: https://api.us-west-2.fragment.dev/*)
  --oauth-url=<value>      The OAuth URL from which to retrieve your auth token (ex:
                           https://auth.fragment.dev/oauth2/token)
  --test                   If set, tests stored credentials only

DESCRIPTION
  Authenticate with FRAGMENT.

  Authentication is scoped to one FRAGMENT Workspace.
  If you want to authenticate with another Workspace, you must create another API Client and follow the authentication
  flow again.
  Credentials will be written to ~/.fragment/auth.json.

EXAMPLES
  $ fragment login

  $ fragment login --client-id <client-id> --client-secret <client-secret> --api-url <api-url> --oauth-url <oauth-url>
```

## `fragment migrate-ledger-entry`

Migrate a Ledger Entry to a new type and version.

```
USAGE
  $ fragment migrate-ledger-entry -e <value> -l <value> -t <value> [-v] [-n <value>] [-p <value>...]

FLAGS
  -e, --entry.id=<value>                (required) The ID of the Ledger Entry to migrate.
  -l, --ledger.ik=<value>               (required) The Idempotency Key of the Ledger containing the entry.
  -n, --new.entry.type.version=<value>  The new version of the Ledger Entry type.
  -p, --param=<value>...                The parameters for the new Ledger Entry. (ex: --param amount=100 --param
                                        currency=USD)
  -t, --new.entry.type=<value>          (required) The new type for the migrated Ledger Entry.
  -v, --verbose                         Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Migrate a Ledger Entry to a new type and version.

  This mirrors the migrateLedgerEntry mutation in the GraphQL API.

  Migrates an existing Ledger Entry to a new type and version with new parameters.


EXAMPLES
  $ fragment migrate-ledger-entry

FLAG DESCRIPTIONS
  -p, --param=<value>...  The parameters for the new Ledger Entry. (ex: --param amount=100 --param currency=USD)

    You may specify multiple parameters by repeating the flag.
```

## `fragment query ledgerAccounts`

Get accounts for ledger within your workspace by ID

```
USAGE
  $ fragment query ledgerAccounts -l <value> [-v] [--first <value>] [--after <value>]

FLAGS
  -l, --ledger=<value>  (required) Ledger ID to retrieve accounts for
  -v, --verbose         Enable verbose mode (prints GraphQL commands).
      --after=<value>   Cursor to paginate through ledger accounts
      --first=<value>   Number of ledger accounts to retrieve in each page

DESCRIPTION
  Get accounts for ledger within your workspace by ID

EXAMPLES
  $ fragment query ledgerAccounts
```

## `fragment query ledgers`

List all ledgers in your workspace

```
USAGE
  $ fragment query ledgers [-v]

FLAGS
  -v, --verbose  Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  List all ledgers in your workspace

EXAMPLES
  $ fragment query ledgers
```

## `fragment query schema`

Get schema from your workspace by key

```
USAGE
  $ fragment query schema -k <value> [-v] [--version <value>]

FLAGS
  -k, --key=<value>      (required) Key of schema (e.g. template-schema)
  -v, --verbose          Enable verbose mode (prints GraphQL commands).
      --version=<value>  Schema version to retrieve (e.g. 2). Defaults to latest available version.

DESCRIPTION
  Get schema from your workspace by key

EXAMPLES
  $ fragment query schema
```

## `fragment query schemas`

List all schemas in your workspace

```
USAGE
  $ fragment query schemas [-v]

FLAGS
  -v, --verbose  Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  List all schemas in your workspace

EXAMPLES
  $ fragment query schemas
```

## `fragment reverse-ledger-entry`

Reverse a Ledger Entry.

```
USAGE
  $ fragment reverse-ledger-entry --id <value> [-v]

FLAGS
  -v, --verbose     Enable verbose mode (prints GraphQL commands).
      --id=<value>  (required) Fragment ID of the Ledger Entry to reverse.

DESCRIPTION
  Reverse a Ledger Entry.

  This mirrors the reverseLedgerEntry mutation in the GraphQL API.

EXAMPLES
  $ fragment reverse-ledger-entry
```

## `fragment start`

Develop your chart of accounts locally

```
USAGE
  $ fragment start [-p <value>] [-f <value>] [--websocket-port <value>]

FLAGS
  -f, --file=<value>            [default: fragment.jsonc] Path for schema JSON file. Default to fragment.jsonc
  -p, --port=<value>            [default: 9410] Port for schema visualizer to run on
      --websocket-port=<value>  Port for the websocket to live on that syncs changes between the CLI and visualizer

DESCRIPTION
  Develop your chart of accounts locally

EXAMPLES
  $ fragment start --file ./my-fragment-schema.json
```

## `fragment store-schema`

Store schema within your Fragment workspace

```
USAGE
  $ fragment store-schema [-v] [-p <value>]

FLAGS
  -p, --path=<value>  [default: fragment.jsonc] Path to schema file (e.g. fragment.jsonc)
  -v, --verbose       Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Store schema within your Fragment workspace

EXAMPLES
  $ fragment store-schema
```

## `fragment token`

Get a FRAGMENT Authentication Token.

```
USAGE
  $ fragment token [-v]

FLAGS
  -v, --verbose  Enable verbose mode (prints GraphQL commands).

EXAMPLES
  $ fragment token
```

## `fragment update`

Update the FRAGMENT CLI

```
USAGE
  $ fragment update [-y] [--dry-run]

FLAGS
  -y, --yes
  --dry-run

DESCRIPTION
  Update the FRAGMENT CLI

EXAMPLES
  $ fragment update
```

## `fragment update-ledger-account`

Update a Ledger Account within your Fragment Ledger.

```
USAGE
  $ fragment update-ledger-account --update.name <value> [-v] [-p <value> | --ledgerAccount.id <value>] [-l <value>]
    [--ledger.id <value>]

FLAGS
  -l, --ledger.ik=<value>           The Idempotency Key of the Ledger the Ledger Account is in.
  -p, --ledgerAccount.path=<value>  The unique path of the Ledger Account.
  -v, --verbose                     Enable verbose mode (prints GraphQL commands).
      --ledger.id=<value>           The Fragment ID of the Ledger the Ledger Account is in.
      --ledgerAccount.id=<value>    The Fragment ID of the Ledger Account.
      --update.name=<value>         (required)

DESCRIPTION
  Update a Ledger Account within your Fragment Ledger.

  This mirrors the updateLedgerAccount mutation in the GraphQL API.

EXAMPLES
  $ fragment update-ledger-account
```

## `fragment verify-schema`

Verify that a schema file follows the Fragment JSON schema format

```
USAGE
  $ fragment verify-schema [-p <value>] [-v] [-j]

FLAGS
  -j, --json          Output validation results as JSON for programmatic use
  -p, --path=<value>  [default: fragment/fragment.json] Path to schema file (e.g. my-schema.jsonc)
  -v, --verbose       Show detailed validation output

DESCRIPTION
  Verify that a schema file follows the Fragment JSON schema format

EXAMPLES
  $ fragment verify-schema

  $ fragment verify-schema --path ./my-schema.jsonc

  $ fragment verify-schema -p fragment/fragment.json --verbose

  $ fragment verify-schema --path ./my-schema.jsonc --json
```

## `fragment workspace`

Get the details of the workspace this CLI is authenticated to

```
USAGE
  $ fragment workspace [-v]

FLAGS
  -v, --verbose  Enable verbose mode (prints GraphQL commands).

DESCRIPTION
  Get the details of the workspace this CLI is authenticated to

EXAMPLES
  $ fragment workspace
```
<!-- commandsstop -->
