go-libfossil: Artifact [67984c506d]

Artifact 67984c506dcadce547f37fd971a21dd99c26e0056004e7d4340a396543bde652:

File docs/site/content/docs/reference/sdk/cli/api.md — part of check-in [c12b02189f] at 2026-10-26 00:46:10 on branch main — docs: regenerate the SDK reference and check it in CI
The gomarkdoc SDK pages had drifted about a thousand lines from the code: make docs-gen-sdk was never part of docs-gen, so nothing regenerated them and the docs check did not compare them. ReadBlob, SetContentCache, ListFilesIn and OriginNamer were missing from the libfossil page.
scripts/gen-sdk-docs.sh now renders them, running gomarkdoc v1.1.0 through go run so CI needs no install, then adds the frontmatter. It honours OUT_DIR, gen-docs.sh calls it, and check-docs-generated.sh compares the result, so a stale SDK page fails CI like any other generated input. make docs-gen-sdk calls the same script. llms.txt and llms-full.txt are regenerated from the refreshed pages. (user: [email protected], size: 68372) [annotate] [blame] [check-ins using] [more...]
---
title: cli
---

<!-- Code generated by gomarkdoc. DO NOT EDIT -->

# cli

```go
import "github.com/danmestas/go-libfossil/cli"
```

## Index

- [Constants](<#constants>)
- [Variables](<#variables>)
- [func Version\(\) string](<#Version>)
- [type ExitError](<#ExitError>)
  - [func \(e \*ExitError\) Error\(\) string](<#ExitError.Error>)
  - [func \(e \*ExitError\) Unwrap\(\) error](<#ExitError.Unwrap>)
- [type Globals](<#Globals>)
  - [func \(g \*Globals\) OpenRepo\(\) \(\*libfossil.Repo, error\)](<#Globals.OpenRepo>)
- [type RecoveryFlags](<#RecoveryFlags>)
- [type RepoAddCmd](<#RepoAddCmd>)
  - [func \(c \*RepoAddCmd\) Run\(g \*Globals\) \(err error\)](<#RepoAddCmd.Run>)
- [type RepoAnnotateCmd](<#RepoAnnotateCmd>)
  - [func \(c \*RepoAnnotateCmd\) Run\(g \*Globals\) error](<#RepoAnnotateCmd.Run>)
- [type RepoBisectBadCmd](<#RepoBisectBadCmd>)
  - [func \(c \*RepoBisectBadCmd\) Run\(g \*Globals\) error](<#RepoBisectBadCmd.Run>)
- [type RepoBisectCmd](<#RepoBisectCmd>)
- [type RepoBisectGoodCmd](<#RepoBisectGoodCmd>)
  - [func \(c \*RepoBisectGoodCmd\) Run\(g \*Globals\) error](<#RepoBisectGoodCmd.Run>)
- [type RepoBisectLsCmd](<#RepoBisectLsCmd>)
  - [func \(c \*RepoBisectLsCmd\) Run\(g \*Globals\) error](<#RepoBisectLsCmd.Run>)
- [type RepoBisectNextCmd](<#RepoBisectNextCmd>)
  - [func \(c \*RepoBisectNextCmd\) Run\(g \*Globals\) error](<#RepoBisectNextCmd.Run>)
- [type RepoBisectResetCmd](<#RepoBisectResetCmd>)
  - [func \(c \*RepoBisectResetCmd\) Run\(g \*Globals\) error](<#RepoBisectResetCmd.Run>)
- [type RepoBisectSkipCmd](<#RepoBisectSkipCmd>)
  - [func \(c \*RepoBisectSkipCmd\) Run\(g \*Globals\) error](<#RepoBisectSkipCmd.Run>)
- [type RepoBisectStatusCmd](<#RepoBisectStatusCmd>)
  - [func \(c \*RepoBisectStatusCmd\) Run\(g \*Globals\) error](<#RepoBisectStatusCmd.Run>)
- [type RepoBlameCmd](<#RepoBlameCmd>)
- [type RepoBranchCloseCmd](<#RepoBranchCloseCmd>)
  - [func \(c \*RepoBranchCloseCmd\) Run\(g \*Globals\) error](<#RepoBranchCloseCmd.Run>)
- [type RepoBranchCmd](<#RepoBranchCmd>)
- [type RepoBranchLsCmd](<#RepoBranchLsCmd>)
  - [func \(c \*RepoBranchLsCmd\) Run\(g \*Globals\) error](<#RepoBranchLsCmd.Run>)
- [type RepoBranchNewCmd](<#RepoBranchNewCmd>)
  - [func \(c \*RepoBranchNewCmd\) Run\(g \*Globals\) error](<#RepoBranchNewCmd.Run>)
- [type RepoCatCmd](<#RepoCatCmd>)
  - [func \(c \*RepoCatCmd\) Run\(g \*Globals\) error](<#RepoCatCmd.Run>)
- [type RepoCiCmd](<#RepoCiCmd>)
  - [func \(c \*RepoCiCmd\) Run\(g \*Globals\) \(err error\)](<#RepoCiCmd.Run>)
- [type RepoCloneCmd](<#RepoCloneCmd>)
  - [func \(c \*RepoCloneCmd\) Run\(g \*Globals\) error](<#RepoCloneCmd.Run>)
- [type RepoCmd](<#RepoCmd>)
- [type RepoCoCmd](<#RepoCoCmd>)
  - [func \(c \*RepoCoCmd\) Run\(g \*Globals\) error](<#RepoCoCmd.Run>)
- [type RepoConeAddCmd](<#RepoConeAddCmd>)
  - [func \(c \*RepoConeAddCmd\) Run\(g \*Globals\) error](<#RepoConeAddCmd.Run>)
- [type RepoConeCmd](<#RepoConeCmd>)
- [type RepoConeCompactCmd](<#RepoConeCompactCmd>)
  - [func \(c \*RepoConeCompactCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeCompactCmd.Run>)
- [type RepoConeCostCmd](<#RepoConeCostCmd>)
  - [func \(c \*RepoConeCostCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeCostCmd.Run>)
- [type RepoConeDeepenCmd](<#RepoConeDeepenCmd>)
  - [func \(c \*RepoConeDeepenCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeDeepenCmd.Run>)
- [type RepoConeDenseCmd](<#RepoConeDenseCmd>)
  - [func \(c \*RepoConeDenseCmd\) Run\(g \*Globals\) error](<#RepoConeDenseCmd.Run>)
- [type RepoConeRemoveCmd](<#RepoConeRemoveCmd>)
  - [func \(c \*RepoConeRemoveCmd\) Run\(g \*Globals\) error](<#RepoConeRemoveCmd.Run>)
- [type RepoConeSetCmd](<#RepoConeSetCmd>)
  - [func \(c \*RepoConeSetCmd\) Run\(g \*Globals\) error](<#RepoConeSetCmd.Run>)
- [type RepoConeShowCmd](<#RepoConeShowCmd>)
  - [func \(c \*RepoConeShowCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeShowCmd.Run>)
- [type RepoConeStoreCmd](<#RepoConeStoreCmd>)
  - [func \(c \*RepoConeStoreCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeStoreCmd.Run>)
- [type RepoConeTestCmd](<#RepoConeTestCmd>)
  - [func \(c \*RepoConeTestCmd\) Run\(g \*Globals\) \(err error\)](<#RepoConeTestCmd.Run>)
- [type RepoConfigCmd](<#RepoConfigCmd>)
- [type RepoConfigGetCmd](<#RepoConfigGetCmd>)
  - [func \(c \*RepoConfigGetCmd\) Run\(g \*Globals\) error](<#RepoConfigGetCmd.Run>)
- [type RepoConfigLsCmd](<#RepoConfigLsCmd>)
  - [func \(c \*RepoConfigLsCmd\) Run\(g \*Globals\) error](<#RepoConfigLsCmd.Run>)
- [type RepoConfigSetCmd](<#RepoConfigSetCmd>)
  - [func \(c \*RepoConfigSetCmd\) Run\(g \*Globals\) error](<#RepoConfigSetCmd.Run>)
- [type RepoConflictsCmd](<#RepoConflictsCmd>)
- [type RepoConflictsExtractCmd](<#RepoConflictsExtractCmd>)
  - [func \(c \*RepoConflictsExtractCmd\) Run\(g \*Globals\) error](<#RepoConflictsExtractCmd.Run>)
- [type RepoConflictsLsCmd](<#RepoConflictsLsCmd>)
  - [func \(c \*RepoConflictsLsCmd\) Run\(g \*Globals\) error](<#RepoConflictsLsCmd.Run>)
- [type RepoConflictsMergeCmd](<#RepoConflictsMergeCmd>)
  - [func \(c \*RepoConflictsMergeCmd\) Run\(g \*Globals\) error](<#RepoConflictsMergeCmd.Run>)
- [type RepoConflictsPickCmd](<#RepoConflictsPickCmd>)
  - [func \(c \*RepoConflictsPickCmd\) Run\(g \*Globals\) error](<#RepoConflictsPickCmd.Run>)
- [type RepoConflictsShowCmd](<#RepoConflictsShowCmd>)
  - [func \(c \*RepoConflictsShowCmd\) Run\(g \*Globals\) error](<#RepoConflictsShowCmd.Run>)
- [type RepoDeltaApplyCmd](<#RepoDeltaApplyCmd>)
  - [func \(c \*RepoDeltaApplyCmd\) Run\(g \*Globals\) error](<#RepoDeltaApplyCmd.Run>)
- [type RepoDeltaCmd](<#RepoDeltaCmd>)
- [type RepoDeltaCreateCmd](<#RepoDeltaCreateCmd>)
  - [func \(c \*RepoDeltaCreateCmd\) Run\(g \*Globals\) error](<#RepoDeltaCreateCmd.Run>)
- [type RepoDiffCmd](<#RepoDiffCmd>)
  - [func \(c \*RepoDiffCmd\) Run\(g \*Globals\) error](<#RepoDiffCmd.Run>)
- [type RepoExtractCmd](<#RepoExtractCmd>)
  - [func \(c \*RepoExtractCmd\) Run\(g \*Globals\) error](<#RepoExtractCmd.Run>)
- [type RepoHashCmd](<#RepoHashCmd>)
  - [func \(c \*RepoHashCmd\) Run\(g \*Globals\) error](<#RepoHashCmd.Run>)
- [type RepoInfoCmd](<#RepoInfoCmd>)
  - [func \(c \*RepoInfoCmd\) Run\(g \*Globals\) error](<#RepoInfoCmd.Run>)
- [type RepoInviteCmd](<#RepoInviteCmd>)
  - [func \(c \*RepoInviteCmd\) Run\(g \*Globals\) error](<#RepoInviteCmd.Run>)
- [type RepoLogCmd](<#RepoLogCmd>)
  - [func \(c \*RepoLogCmd\) Run\(g \*Globals\) \(err error\)](<#RepoLogCmd.Run>)
- [type RepoLsCmd](<#RepoLsCmd>)
  - [func \(c \*RepoLsCmd\) Run\(g \*Globals\) error](<#RepoLsCmd.Run>)
- [type RepoMergeCmd](<#RepoMergeCmd>)
  - [func \(c \*RepoMergeCmd\) Run\(g \*Globals\) \(err error\)](<#RepoMergeCmd.Run>)
- [type RepoMergeResolveCmd](<#RepoMergeResolveCmd>)
  - [func \(c \*RepoMergeResolveCmd\) Run\(g \*Globals\) \(err error\)](<#RepoMergeResolveCmd.Run>)
- [type RepoNewCmd](<#RepoNewCmd>)
  - [func \(c \*RepoNewCmd\) Run\(g \*Globals\) error](<#RepoNewCmd.Run>)
- [type RepoOpenCmd](<#RepoOpenCmd>)
  - [func \(c \*RepoOpenCmd\) Run\(g \*Globals\) error](<#RepoOpenCmd.Run>)
- [type RepoQueryCmd](<#RepoQueryCmd>)
  - [func \(c \*RepoQueryCmd\) Run\(g \*Globals\) error](<#RepoQueryCmd.Run>)
- [type RepoRedoCmd](<#RepoRedoCmd>)
  - [func \(c \*RepoRedoCmd\) Run\(g \*Globals\) error](<#RepoRedoCmd.Run>)
- [type RepoRenameCmd](<#RepoRenameCmd>)
  - [func \(c \*RepoRenameCmd\) Run\(g \*Globals\) \(err error\)](<#RepoRenameCmd.Run>)
- [type RepoResolveCmd](<#RepoResolveCmd>)
  - [func \(c \*RepoResolveCmd\) Run\(g \*Globals\) error](<#RepoResolveCmd.Run>)
- [type RepoRevertCmd](<#RepoRevertCmd>)
  - [func \(c \*RepoRevertCmd\) Run\(g \*Globals\) \(err error\)](<#RepoRevertCmd.Run>)
- [type RepoRmCmd](<#RepoRmCmd>)
  - [func \(c \*RepoRmCmd\) Run\(g \*Globals\) \(err error\)](<#RepoRmCmd.Run>)
- [type RepoSchemaAddCmd](<#RepoSchemaAddCmd>)
  - [func \(c \*RepoSchemaAddCmd\) Run\(g \*Globals\) error](<#RepoSchemaAddCmd.Run>)
- [type RepoSchemaCmd](<#RepoSchemaCmd>)
- [type RepoSchemaListCmd](<#RepoSchemaListCmd>)
  - [func \(c \*RepoSchemaListCmd\) Run\(g \*Globals\) error](<#RepoSchemaListCmd.Run>)
- [type RepoSchemaRemoveCmd](<#RepoSchemaRemoveCmd>)
  - [func \(c \*RepoSchemaRemoveCmd\) Run\(g \*Globals\) error](<#RepoSchemaRemoveCmd.Run>)
- [type RepoSchemaShowCmd](<#RepoSchemaShowCmd>)
  - [func \(c \*RepoSchemaShowCmd\) Run\(g \*Globals\) error](<#RepoSchemaShowCmd.Run>)
- [type RepoServeCmd](<#RepoServeCmd>)
  - [func \(c \*RepoServeCmd\) Run\(g \*Globals\) error](<#RepoServeCmd.Run>)
- [type RepoSnapshotCmd](<#RepoSnapshotCmd>)
  - [func \(c \*RepoSnapshotCmd\) Run\(g \*Globals\) \(err error\)](<#RepoSnapshotCmd.Run>)
- [type RepoStashApplyCmd](<#RepoStashApplyCmd>)
  - [func \(c \*RepoStashApplyCmd\) Run\(g \*Globals\) error](<#RepoStashApplyCmd.Run>)
- [type RepoStashClearCmd](<#RepoStashClearCmd>)
  - [func \(c \*RepoStashClearCmd\) Run\(g \*Globals\) error](<#RepoStashClearCmd.Run>)
- [type RepoStashCmd](<#RepoStashCmd>)
- [type RepoStashDropCmd](<#RepoStashDropCmd>)
  - [func \(c \*RepoStashDropCmd\) Run\(g \*Globals\) error](<#RepoStashDropCmd.Run>)
- [type RepoStashLsCmd](<#RepoStashLsCmd>)
  - [func \(c \*RepoStashLsCmd\) Run\(g \*Globals\) error](<#RepoStashLsCmd.Run>)
- [type RepoStashPopCmd](<#RepoStashPopCmd>)
  - [func \(c \*RepoStashPopCmd\) Run\(g \*Globals\) error](<#RepoStashPopCmd.Run>)
- [type RepoStashSaveCmd](<#RepoStashSaveCmd>)
  - [func \(c \*RepoStashSaveCmd\) Run\(g \*Globals\) error](<#RepoStashSaveCmd.Run>)
- [type RepoStatusCmd](<#RepoStatusCmd>)
  - [func \(c \*RepoStatusCmd\) Run\(g \*Globals\) error](<#RepoStatusCmd.Run>)
- [type RepoSubmanifestsCmd](<#RepoSubmanifestsCmd>)
- [type RepoSubmanifestsDisableCmd](<#RepoSubmanifestsDisableCmd>)
  - [func \(c \*RepoSubmanifestsDisableCmd\) Run\(g \*Globals\) error](<#RepoSubmanifestsDisableCmd.Run>)
- [type RepoSubmanifestsEnableCmd](<#RepoSubmanifestsEnableCmd>)
  - [func \(c \*RepoSubmanifestsEnableCmd\) Run\(g \*Globals\) error](<#RepoSubmanifestsEnableCmd.Run>)
- [type RepoSubmanifestsRetuneCmd](<#RepoSubmanifestsRetuneCmd>)
  - [func \(c \*RepoSubmanifestsRetuneCmd\) Run\(g \*Globals\) error](<#RepoSubmanifestsRetuneCmd.Run>)
- [type RepoSubmanifestsStatusCmd](<#RepoSubmanifestsStatusCmd>)
  - [func \(c \*RepoSubmanifestsStatusCmd\) Run\(g \*Globals\) error](<#RepoSubmanifestsStatusCmd.Run>)
- [type RepoTagAddCmd](<#RepoTagAddCmd>)
  - [func \(c \*RepoTagAddCmd\) Run\(g \*Globals\) error](<#RepoTagAddCmd.Run>)
- [type RepoTagCmd](<#RepoTagCmd>)
- [type RepoTagLsCmd](<#RepoTagLsCmd>)
  - [func \(c \*RepoTagLsCmd\) Run\(g \*Globals\) error](<#RepoTagLsCmd.Run>)
- [type RepoTimelineCmd](<#RepoTimelineCmd>)
  - [func \(c \*RepoTimelineCmd\) Run\(g \*Globals\) error](<#RepoTimelineCmd.Run>)
- [type RepoUVCmd](<#RepoUVCmd>)
- [type RepoUVDeleteCmd](<#RepoUVDeleteCmd>)
  - [func \(c \*RepoUVDeleteCmd\) Run\(g \*Globals\) error](<#RepoUVDeleteCmd.Run>)
- [type RepoUVGetCmd](<#RepoUVGetCmd>)
  - [func \(c \*RepoUVGetCmd\) Run\(g \*Globals\) error](<#RepoUVGetCmd.Run>)
- [type RepoUVLsCmd](<#RepoUVLsCmd>)
  - [func \(c \*RepoUVLsCmd\) Run\(g \*Globals\) error](<#RepoUVLsCmd.Run>)
- [type RepoUVPutCmd](<#RepoUVPutCmd>)
  - [func \(c \*RepoUVPutCmd\) Run\(g \*Globals\) error](<#RepoUVPutCmd.Run>)
- [type RepoUndoCmd](<#RepoUndoCmd>)
  - [func \(c \*RepoUndoCmd\) Run\(g \*Globals\) error](<#RepoUndoCmd.Run>)
- [type RepoUserCmd](<#RepoUserCmd>)
- [type RepoVerifyCmd](<#RepoVerifyCmd>)
  - [func \(c \*RepoVerifyCmd\) Run\(g \*Globals\) error](<#RepoVerifyCmd.Run>)
- [type RepoWikiCmd](<#RepoWikiCmd>)
- [type RepoWikiExportCmd](<#RepoWikiExportCmd>)
  - [func \(c \*RepoWikiExportCmd\) Run\(g \*Globals\) error](<#RepoWikiExportCmd.Run>)
- [type RepoWikiLsCmd](<#RepoWikiLsCmd>)
  - [func \(c \*RepoWikiLsCmd\) Run\(g \*Globals\) error](<#RepoWikiLsCmd.Run>)
- [type UserAddCmd](<#UserAddCmd>)
  - [func \(c \*UserAddCmd\) Run\(g \*Globals\) error](<#UserAddCmd.Run>)
- [type UserListCmd](<#UserListCmd>)
  - [func \(c \*UserListCmd\) Run\(g \*Globals\) error](<#UserListCmd.Run>)
- [type UserPasswdCmd](<#UserPasswdCmd>)
  - [func \(c \*UserPasswdCmd\) Run\(g \*Globals\) error](<#UserPasswdCmd.Run>)
- [type UserRmCmd](<#UserRmCmd>)
  - [func \(c \*UserRmCmd\) Run\(g \*Globals\) error](<#UserRmCmd.Run>)
- [type UserUpdateCmd](<#UserUpdateCmd>)
  - [func \(c \*UserUpdateCmd\) Run\(g \*Globals\) error](<#UserUpdateCmd.Run>)
- [type VersionCmd](<#VersionCmd>)
  - [func \(c \*VersionCmd\) Run\(\) error](<#VersionCmd.Run>)


## Constants

<a name="ExitOK"></a>Exit statuses the machine\-facing commands \(snapshot, log, cat \-\-at, diff\) document and keep stable. Every other failure, including a usage error, is ExitFailure.

```go
const (
    ExitOK       = 0
    ExitFailure  = 1
    ExitNotFound = 2 // the version, path or history asked for does not exist
)
```

## Variables

<a name="ErrConeTestElided"></a>ErrConeTestElided is what \`repo cone test\` returns when any path it was given is outside the cone, so the command works as a predicate.

```go
var ErrConeTestElided = errors.New("a path is elided by the sparse cone")
```

<a name="Version"></a>
## func Version

```go
func Version() string
```

Version returns a single\-line build identifier for this binary: the module version \(or a build\-time override\), the Go toolchain version, and the platform. The shape is fixed at four whitespace\-separated fields \-\- "libfossil \<version\> \<go version\> \<os\>/\<arch\>" \-\- regardless of which fields carried real data, so a caller can rely on strings.Fields\(Version\(\)\) unconditionally. This is the same string both \`libfossil version\` and \`libfossil \-\-version\` print.

<a name="ExitError"></a>
## type ExitError

ExitError is a command failure that carries the process exit status it maps to. The binary's main exits with Code after printing Err.

```go
type ExitError struct {
    Code int
    Err  error
}
```

<a name="ExitError.Error"></a>
### func \(\*ExitError\) Error

```go
func (e *ExitError) Error() string
```



<a name="ExitError.Unwrap"></a>
### func \(\*ExitError\) Unwrap

```go
func (e *ExitError) Unwrap() error
```



<a name="Globals"></a>
## type Globals

Globals holds flags shared by all CLI commands.

```go
type Globals struct {
    Repo    string `short:"R" help:"Path to repository file" type:"path"`
    Verbose bool   `short:"v" help:"Verbose output"`
}
```

<a name="Globals.OpenRepo"></a>
### func \(\*Globals\) OpenRepo

```go
func (g *Globals) OpenRepo() (*libfossil.Repo, error)
```

OpenRepo opens a Fossil repository using the handle API. If Repo is empty, it searches for a .fossil file or checkout database.

<a name="RecoveryFlags"></a>
## type RecoveryFlags

RecoveryFlags selects only the peer and credentials used to obtain content a local operation requires. It does not enable ordinary pull, push or autosync.

```go
type RecoveryFlags struct {
    Remote      string        `help:"Required-content peer URL (default: saved last-sync-url)"`
    SyncUser    string        `help:"Required-content authentication user"`
    SyncPass    string        `help:"Required-content password (never saved)"`
    SyncPrivate bool          `help:"Allow recovery of private required artifacts"`
    Timeout     time.Duration `default:"10m" help:"Required-content deadline; 0 disables it"`
}
```

<a name="RepoAddCmd"></a>
## type RepoAddCmd

RepoAddCmd stages files for addition in the checkout database.

```go
type RepoAddCmd struct {
    Files []string `arg:"" required:"" help:"Files to stage for addition"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoAddCmd.Run"></a>
### func \(\*RepoAddCmd\) Run

```go
func (c *RepoAddCmd) Run(g *Globals) (err error)
```



<a name="RepoAnnotateCmd"></a>
## type RepoAnnotateCmd

RepoAnnotateCmd annotates file lines with version history.

```go
type RepoAnnotateCmd struct {
    File    string `arg:"" required:"" help:"File to annotate"`
    Version string `help:"Starting version (default: tip)"`
}
```

<a name="RepoAnnotateCmd.Run"></a>
### func \(\*RepoAnnotateCmd\) Run

```go
func (c *RepoAnnotateCmd) Run(g *Globals) error
```



<a name="RepoBisectBadCmd"></a>
## type RepoBisectBadCmd

RepoBisectBadCmd marks a version as bad.

```go
type RepoBisectBadCmd struct {
    Version string `arg:"" optional:"" help:"Version to mark (default: current checkout)"`
    Dir     string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectBadCmd.Run"></a>
### func \(\*RepoBisectBadCmd\) Run

```go
func (c *RepoBisectBadCmd) Run(g *Globals) error
```



<a name="RepoBisectCmd"></a>
## type RepoBisectCmd

RepoBisectCmd groups binary search operations.

```go
type RepoBisectCmd struct {
    Good   RepoBisectGoodCmd   `cmd:"" help:"Mark version as good"`
    Bad    RepoBisectBadCmd    `cmd:"" help:"Mark version as bad"`
    Next   RepoBisectNextCmd   `cmd:"" help:"Check out midpoint version"`
    Skip   RepoBisectSkipCmd   `cmd:"" help:"Skip current version"`
    Reset  RepoBisectResetCmd  `cmd:"" help:"Clear bisect state"`
    Ls     RepoBisectLsCmd     `cmd:"" help:"Show bisect path"`
    Status RepoBisectStatusCmd `cmd:"" help:"Show bisect state"`
}
```

<a name="RepoBisectGoodCmd"></a>
## type RepoBisectGoodCmd

RepoBisectGoodCmd marks a version as good.

```go
type RepoBisectGoodCmd struct {
    Version string `arg:"" optional:"" help:"Version to mark (default: current checkout)"`
    Dir     string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectGoodCmd.Run"></a>
### func \(\*RepoBisectGoodCmd\) Run

```go
func (c *RepoBisectGoodCmd) Run(g *Globals) error
```



<a name="RepoBisectLsCmd"></a>
## type RepoBisectLsCmd

RepoBisectLsCmd shows the bisect path.

```go
type RepoBisectLsCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectLsCmd.Run"></a>
### func \(\*RepoBisectLsCmd\) Run

```go
func (c *RepoBisectLsCmd) Run(g *Globals) error
```



<a name="RepoBisectNextCmd"></a>
## type RepoBisectNextCmd

RepoBisectNextCmd checks out the bisect midpoint version.

```go
type RepoBisectNextCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectNextCmd.Run"></a>
### func \(\*RepoBisectNextCmd\) Run

```go
func (c *RepoBisectNextCmd) Run(g *Globals) error
```



<a name="RepoBisectResetCmd"></a>
## type RepoBisectResetCmd

RepoBisectResetCmd clears bisect state.

```go
type RepoBisectResetCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectResetCmd.Run"></a>
### func \(\*RepoBisectResetCmd\) Run

```go
func (c *RepoBisectResetCmd) Run(g *Globals) error
```



<a name="RepoBisectSkipCmd"></a>
## type RepoBisectSkipCmd

RepoBisectSkipCmd skips the current version.

```go
type RepoBisectSkipCmd struct {
    Version string `arg:"" optional:"" help:"Version to skip (default: current checkout)"`
    Dir     string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectSkipCmd.Run"></a>
### func \(\*RepoBisectSkipCmd\) Run

```go
func (c *RepoBisectSkipCmd) Run(g *Globals) error
```



<a name="RepoBisectStatusCmd"></a>
## type RepoBisectStatusCmd

RepoBisectStatusCmd shows bisect state.

```go
type RepoBisectStatusCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoBisectStatusCmd.Run"></a>
### func \(\*RepoBisectStatusCmd\) Run

```go
func (c *RepoBisectStatusCmd) Run(g *Globals) error
```



<a name="RepoBlameCmd"></a>
## type RepoBlameCmd

RepoBlameCmd is an alias for annotate.

```go
type RepoBlameCmd struct {
    RepoAnnotateCmd
}
```

<a name="RepoBranchCloseCmd"></a>
## type RepoBranchCloseCmd

RepoBranchCloseCmd closes a branch.

```go
type RepoBranchCloseCmd struct {
    Name string `arg:"" help:"Branch name to close"`
    User string `help:"User for control artifacts (default: OS username)"`
}
```

<a name="RepoBranchCloseCmd.Run"></a>
### func \(\*RepoBranchCloseCmd\) Run

```go
func (c *RepoBranchCloseCmd) Run(g *Globals) error
```



<a name="RepoBranchCmd"></a>
## type RepoBranchCmd

RepoBranchCmd groups branch operations.

```go
type RepoBranchCmd struct {
    Ls    RepoBranchLsCmd    `cmd:"" help:"List branches"`
    New   RepoBranchNewCmd   `cmd:"" help:"Create new branch"`
    Close RepoBranchCloseCmd `cmd:"" help:"Close a branch"`
}
```

<a name="RepoBranchLsCmd"></a>
## type RepoBranchLsCmd

RepoBranchLsCmd lists branches.

```go
type RepoBranchLsCmd struct {
    Closed bool `help:"Show only closed branches"`
    All    bool `help:"Show all branches (open and closed)"`
}
```

<a name="RepoBranchLsCmd.Run"></a>
### func \(\*RepoBranchLsCmd\) Run

```go
func (c *RepoBranchLsCmd) Run(g *Globals) error
```



<a name="RepoBranchNewCmd"></a>
## type RepoBranchNewCmd

RepoBranchNewCmd creates a new branch.

```go
type RepoBranchNewCmd struct {
    Name    string `arg:"" help:"Branch name"`
    From    string `help:"Parent version (default: tip)"`
    Message string `short:"m" help:"Checkin comment"`
    User    string `help:"Checkin user (default: OS username)"`
    NoSign  bool   `name:"nosign" help:"Do not sign the branch's check-in, even with the clearsign setting on"`
}
```

<a name="RepoBranchNewCmd.Run"></a>
### func \(\*RepoBranchNewCmd\) Run

```go
func (c *RepoBranchNewCmd) Run(g *Globals) error
```



<a name="RepoCatCmd"></a>
## type RepoCatCmd

RepoCatCmd outputs the content of an artifact, or with \-\-at the content of a file as a version holds it, as fossil cat \-r does.

```go
type RepoCatCmd struct {
    Artifact string `arg:"" help:"Artifact UUID or prefix; with --at, the file name"`
    At       string `name:"at" short:"r" help:"Version to read the file from (tip, trunk, a branch, a uuid or prefix)"`
    Raw      bool   `help:"Output raw blob (no delta expansion)"`
}
```

<a name="RepoCatCmd.Run"></a>
### func \(\*RepoCatCmd\) Run

```go
func (c *RepoCatCmd) Run(g *Globals) error
```



<a name="RepoCiCmd"></a>
## type RepoCiCmd

RepoCiCmd commits the checkout's changes, as fossil's commit command does: every change, or only the named files. A pending merge is committed with the merged\-in checkin as a merge parent.

```go
type RepoCiCmd struct {
    RecoveryFlags
    NoSync        bool     `help:"Suppress optional autosync, not required-content recovery"`
    Message       string   `short:"m" required:"" help:"Checkin comment"`
    Files         []string `arg:"" optional:"" help:"Files to commit (default: all changes)"`
    User          string   `help:"Checkin user (default: OS username)"`
    Branch        string   `help:"Branch name for this checkin"`
    AllowConflict bool     `help:"Commit files that still hold merge conflict markers"`
    AllowEmpty    bool     `help:"Commit even when nothing has changed"`
    NoSign        bool     `name:"nosign" help:"Do not sign this check-in, even with the clearsign setting on"`
    Dir           string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoCiCmd.Run"></a>
### func \(\*RepoCiCmd\) Run

```go
func (c *RepoCiCmd) Run(g *Globals) (err error)
```



<a name="RepoCloneCmd"></a>
## type RepoCloneCmd

RepoCloneCmd clones a remote Fossil repository.

```go
type RepoCloneCmd struct {
    URL        string        `arg:"" optional:"" help:"Remote Fossil server URL"`
    Path       string        `arg:"" optional:"" help:"Local path for new repository file"`
    User       string        `short:"u" help:"Username for clone auth"`
    Pass       string        `short:"p" help:"Password for clone auth"`
    Invite     string        `help:"Invite token (from fossil invite)"`
    Timeout    time.Duration `default:"10m" help:"Abort the clone if it runs longer than this; 0 disables the deadline"`
    Horizon    string        `help:"Clone a horizon store: elide blobs below this check-in, given as tip, a branch or tag, or its full 40 or 64 digit hash; the origin resolves a name, or the clone does over what an origin that cannot sends it; what each rule would hold needs a local repository ('repo cone cost') or a peer that exposes it out of band, as the origin's horizon-served URL may"`
    Depth      int           `help:"With --horizon, step the check-in back this many check-ins along primary parents, stopping at a root"`
    Leaves     bool          `help:"With --horizon, also hold every open leaf's ancestry back to the check-in, for merging across live branches offline; costly: on a repository with old unmerged branches that is nearly the whole history"`
    Structural bool          `help:"With --horizon, also elide the manifests below the check-in, deriving their branch and tag state from the origin's seed"`
    Cone       []string      `name:"cone" help:"Clone a sparse store: fetch only this path's subtree (repeatable)"`
    ConeNot    []string      `name:"cone-not" help:"Carve this path out of a --cone (repeatable)"`
    SeedKey    string        `name:"seed-key" help:"The origin's public key, an SSH public key line or an OpenPGP fingerprint: with --structural, a horizon seed not signed by it is discarded and the clone falls back to the content horizon; kept as the horizon-seed-key setting"`
}
```

<a name="RepoCloneCmd.Run"></a>
### func \(\*RepoCloneCmd\) Run

```go
func (c *RepoCloneCmd) Run(g *Globals) error
```



<a name="RepoCmd"></a>
## type RepoCmd

RepoCmd is the top\-level command group for repository operations. Embed this in your CLI struct alongside Globals for a complete fossil CLI.

```go
type RepoCmd struct {
    New          RepoNewCmd          `cmd:"" help:"Create a new repository"`
    Clone        RepoCloneCmd        `cmd:"" help:"Clone a remote repository"`
    Ci           RepoCiCmd           `cmd:"" help:"Checkin file changes"`
    Co           RepoCoCmd           `cmd:"" help:"Checkout a version"`
    Ls           RepoLsCmd           `cmd:"" help:"List files in a version"`
    Timeline     RepoTimelineCmd     `cmd:"" help:"Show repository history"`
    Snapshot     RepoSnapshotCmd     `cmd:"" help:"Commit a file's bytes onto trunk, no checkout needed"`
    Log          RepoLogCmd          `cmd:"" help:"Show the check-ins that changed a path"`
    Cat          RepoCatCmd          `cmd:"" help:"Output artifact content"`
    Info         RepoInfoCmd         `cmd:"" help:"Repository statistics"`
    Hash         RepoHashCmd         `cmd:"" help:"Hash files (SHA1 or SHA3)"`
    Delta        RepoDeltaCmd        `cmd:"" help:"Delta create/apply operations"`
    Config       RepoConfigCmd       `cmd:"" help:"Repository configuration"`
    Query        RepoQueryCmd        `cmd:"" help:"Execute SQL against repository"`
    Verify       RepoVerifyCmd       `cmd:"" help:"Verify repository integrity"`
    Resolve      RepoResolveCmd      `cmd:"" help:"Resolve symbolic name to UUID"`
    Extract      RepoExtractCmd      `cmd:"" help:"Extract files from a version"`
    Wiki         RepoWikiCmd         `cmd:"" help:"Wiki page operations"`
    Tag          RepoTagCmd          `cmd:"" help:"Tag operations"`
    Open         RepoOpenCmd         `cmd:"" help:"Open a checkout in a directory"`
    Status       RepoStatusCmd       `cmd:"" help:"Show working directory changes"`
    Add          RepoAddCmd          `cmd:"" help:"Stage files for addition"`
    Rm           RepoRmCmd           `cmd:"" help:"Stage files for removal"`
    Rename       RepoRenameCmd       `cmd:"" help:"Rename a tracked file"`
    Revert       RepoRevertCmd       `cmd:"" help:"Undo staging changes"`
    Diff         RepoDiffCmd         `cmd:"" help:"Show changes vs a version"`
    Merge        RepoMergeCmd        `cmd:"" help:"Merge a divergent version"`
    Conflicts    RepoConflictsCmd    `cmd:"" help:"List/manage unresolved conflicts"`
    MarkResolved RepoMergeResolveCmd `cmd:"" name:"mark-resolved" help:"Mark a conflict as resolved"`
    Undo         RepoUndoCmd         `cmd:"" help:"Undo last operation"`
    Redo         RepoRedoCmd         `cmd:"" help:"Redo undone operation"`
    Stash        RepoStashCmd        `cmd:"" help:"Stash working changes"`
    Bisect       RepoBisectCmd       `cmd:"" help:"Binary search for bugs"`
    Annotate     RepoAnnotateCmd     `cmd:"" help:"Annotate file lines with version history"`
    Blame        RepoBlameCmd        `cmd:"" help:"Alias for annotate"`
    Branch       RepoBranchCmd       `cmd:"" help:"Branch operations"`
    UV           RepoUVCmd           `cmd:"" name:"uv" help:"Unversioned file operations"`
    Schema       RepoSchemaCmd       `cmd:"" help:"Synced table schema operations"`
    User         RepoUserCmd         `cmd:"" help:"User management"`
    Invite       RepoInviteCmd       `cmd:"" help:"Generate invite token for a user"`
    Serve        RepoServeCmd        `cmd:"" help:"Serve repository over HTTP for sync/clone"`
    Submanifests RepoSubmanifestsCmd `cmd:"" help:"Sub-manifest tree settings"`
    Cone         RepoConeCmd         `cmd:"" help:"Show or edit a checkout's sparse cone"`
}
```

<a name="RepoCoCmd"></a>
## type RepoCoCmd

RepoCoCmd checks out a version to the working directory.

```go
type RepoCoCmd struct {
    Version string `arg:"" optional:"" help:"Version to checkout (default: tip)"`
    Dir     string `short:"d" help:"Output directory (default: current dir)" default:"."`
    Force   bool   `help:"Overwrite existing files"`
}
```

<a name="RepoCoCmd.Run"></a>
### func \(\*RepoCoCmd\) Run

```go
func (c *RepoCoCmd) Run(g *Globals) error
```



<a name="RepoConeAddCmd"></a>
## type RepoConeAddCmd

RepoConeAddCmd adds members to the cone.

```go
type RepoConeAddCmd struct {
    RecoveryFlags
    Paths []string `arg:"" help:"Paths to add"`
    Not   bool     `help:"Add the paths as exclusions"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeAddCmd.Run"></a>
### func \(\*RepoConeAddCmd\) Run

```go
func (c *RepoConeAddCmd) Run(g *Globals) error
```



<a name="RepoConeCmd"></a>
## type RepoConeCmd

RepoConeCmd shows or edits a checkout's sparse cone \(draft\-fossil\-sparse\-cone\-00\): the paths, directory subtrees or single files, that the checkout materializes and tracks. An exclusion carves a part out of an inclusion; the longest member covering a path decides.

```go
type RepoConeCmd struct {
    Show    RepoConeShowCmd    `cmd:"" default:"withargs" help:"List the cone's members (\"dense\" when there is none)"`
    Add     RepoConeAddCmd     `cmd:"" help:"Widen the cone, or with --not carve paths out of it"`
    Remove  RepoConeRemoveCmd  `cmd:"" help:"Remove members of either polarity"`
    Set     RepoConeSetCmd     `cmd:"" help:"Replace the cone"`
    Dense   RepoConeDenseCmd   `cmd:"" help:"Drop the cone and materialize every file"`
    Test    RepoConeTestCmd    `cmd:"" help:"Classify paths against the cone and name the deciding member"`
    Store   RepoConeStoreCmd   `cmd:"" help:"Show or replace the repository's store cone, fetching what widening covers"`
    Deepen  RepoConeDeepenCmd  `cmd:"" help:"Move the store's horizon down to reach a check-in, fetching the history it keeps"`
    Compact RepoConeCompactCmd `cmd:"" help:"Drop held blobs the store cone elides (irreversible locally)"`
    Cost    RepoConeCostCmd    `cmd:"" help:"Report what each horizon rule would hold at a check-in, from this repository"`
}
```

<a name="RepoConeCompactCmd"></a>
## type RepoConeCompactCmd

RepoConeCompactCmd is the narrow\-then\-compact deletion, zit's \`pack \-\-drop\-elided\`: it acts on the store cone, not a checkout's, and a later widening fetches the dropped blobs from a peer.

```go
type RepoConeCompactCmd struct{}
```

<a name="RepoConeCompactCmd.Run"></a>
### func \(\*RepoConeCompactCmd\) Run

```go
func (c *RepoConeCompactCmd) Run(g *Globals) (err error)
```



<a name="RepoConeCostCmd"></a>
## type RepoConeCostCmd

RepoConeCostCmd reports what a horizon at a check\-in would hold under each rule \(draft\-fossil\-horizon\-00 §3.4\): the check\-ins of the held set and the bytes of the blobs they name, stored and expanded, so the rule is chosen with its cost in view. It reads the local repository, which must hold the history; a clone has none yet, so the figures come before it, from a peer that exposes them \(an origin may name such an interface through horizon\-served\) or from a repository already held.

```go
type RepoConeCostCmd struct {
    Checkin string `arg:"" help:"Check-in to place the horizon at: a name, branch or hash prefix"`
}
```

<a name="RepoConeCostCmd.Run"></a>
### func \(\*RepoConeCostCmd\) Run

```go
func (c *RepoConeCostCmd) Run(g *Globals) (err error)
```



<a name="RepoConeDeepenCmd"></a>
## type RepoConeDeepenCmd

RepoConeDeepenCmd deepens the store's horizon \(draft\-fossil\-horizon\-00 §5.8\) so that it reaches a check\-in: C moves to that check\-in when it is an ancestor of C, else to a common ancestor of the two, which the remote is asked for when the store cannot see one. The rule, the depth and the path members stay. History comes from \-\-remote, else the saved last\-sync\-url.

```go
type RepoConeDeepenCmd struct {
    RecoveryFlags
    Checkin string `arg:"" help:"Check-in to reach: a full hash, which may lie below the horizon, or a name"`
}
```

<a name="RepoConeDeepenCmd.Run"></a>
### func \(\*RepoConeDeepenCmd\) Run

```go
func (c *RepoConeDeepenCmd) Run(g *Globals) (err error)
```



<a name="RepoConeDenseCmd"></a>
## type RepoConeDenseCmd

RepoConeDenseCmd drops the cone.

```go
type RepoConeDenseCmd struct {
    RecoveryFlags
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeDenseCmd.Run"></a>
### func \(\*RepoConeDenseCmd\) Run

```go
func (c *RepoConeDenseCmd) Run(g *Globals) error
```



<a name="RepoConeRemoveCmd"></a>
## type RepoConeRemoveCmd

RepoConeRemoveCmd removes members from the cone.

```go
type RepoConeRemoveCmd struct {
    RecoveryFlags
    Paths []string `arg:"" help:"Members to remove"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeRemoveCmd.Run"></a>
### func \(\*RepoConeRemoveCmd\) Run

```go
func (c *RepoConeRemoveCmd) Run(g *Globals) error
```



<a name="RepoConeSetCmd"></a>
## type RepoConeSetCmd

RepoConeSetCmd replaces the cone.

```go
type RepoConeSetCmd struct {
    RecoveryFlags
    Paths []string `arg:"" help:"Inclusion members"`
    Not   []string `help:"Exclusion members (repeatable)"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeSetCmd.Run"></a>
### func \(\*RepoConeSetCmd\) Run

```go
func (c *RepoConeSetCmd) Run(g *Globals) error
```



<a name="RepoConeShowCmd"></a>
## type RepoConeShowCmd

RepoConeShowCmd lists the inclusions, then the exclusions marked '\!'.

```go
type RepoConeShowCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeShowCmd.Run"></a>
### func \(\*RepoConeShowCmd\) Run

```go
func (c *RepoConeShowCmd) Run(g *Globals) (err error)
```



<a name="RepoConeStoreCmd"></a>
## type RepoConeStoreCmd

RepoConeStoreCmd shows or replaces the repository's store cone, the policy form of demand fetch \(draft\-fossil\-sparse\-cone\-00 §6.4\): artifacts the new cone covers that the old one elided are pulled from \-\-remote, else the saved last\-sync\-url. With such artifacts and no peer it refuses and changes nothing.

A store cone may carry a horizon \(draft\-fossil\-horizon\-00\): \-\-horizon sets it, or deepens it when the check\-in is older than the current one, with \-\-structural taking the structural cut, and \-\-no\-horizon drops it. Either keeps the store's path members unless paths are given, which replace them.

```go
type RepoConeStoreCmd struct {
    RecoveryFlags
    Paths      []string `arg:"" optional:"" help:"Inclusion members; none shows the store cone"`
    Not        []string `help:"Exclusion members (repeatable)"`
    Dense      bool     `help:"Drop the store cone, fetching everything it elided"`
    Horizon    string   `help:"Elide blobs below this check-in (name, branch or hash prefix), fetching what a deeper horizon keeps; 'repo cone cost' shows what each rule would hold"`
    Leaves     bool     `help:"With --horizon, also hold every open leaf's ancestry back to the check-in, for merging across live branches offline; costly: on a repository with old unmerged branches that is nearly the whole history"`
    Structural bool     `help:"With --horizon, also elide the manifests below the check-in; the next pull fetches the origin's seed"`
    NoHorizon  bool     `help:"Drop the horizon, keeping the path members, and fetch what it elided"`
}
```

<a name="RepoConeStoreCmd.Run"></a>
### func \(\*RepoConeStoreCmd\) Run

```go
func (c *RepoConeStoreCmd) Run(g *Globals) (err error)
```



<a name="RepoConeTestCmd"></a>
## type RepoConeTestCmd

RepoConeTestCmd classifies paths as zit's \`cone test\` does.

```go
type RepoConeTestCmd struct {
    Paths []string `arg:"" help:"Paths to classify"`
    Quiet bool     `short:"q" help:"Print nothing; report through the exit status only"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConeTestCmd.Run"></a>
### func \(\*RepoConeTestCmd\) Run

```go
func (c *RepoConeTestCmd) Run(g *Globals) (err error)
```



<a name="RepoConfigCmd"></a>
## type RepoConfigCmd

RepoConfigCmd groups configuration operations.

```go
type RepoConfigCmd struct {
    Ls  RepoConfigLsCmd  `cmd:"" help:"List all config entries"`
    Get RepoConfigGetCmd `cmd:"" help:"Get a config value"`
    Set RepoConfigSetCmd `cmd:"" help:"Set a config value"`
}
```

<a name="RepoConfigGetCmd"></a>
## type RepoConfigGetCmd

RepoConfigGetCmd gets a single config value.

```go
type RepoConfigGetCmd struct {
    Key string `arg:"" help:"Config key to get"`
}
```

<a name="RepoConfigGetCmd.Run"></a>
### func \(\*RepoConfigGetCmd\) Run

```go
func (c *RepoConfigGetCmd) Run(g *Globals) error
```



<a name="RepoConfigLsCmd"></a>
## type RepoConfigLsCmd

RepoConfigLsCmd lists all config entries.

```go
type RepoConfigLsCmd struct{}
```

<a name="RepoConfigLsCmd.Run"></a>
### func \(\*RepoConfigLsCmd\) Run

```go
func (c *RepoConfigLsCmd) Run(g *Globals) error
```



<a name="RepoConfigSetCmd"></a>
## type RepoConfigSetCmd

RepoConfigSetCmd sets a config value.

```go
type RepoConfigSetCmd struct {
    Key   string `arg:"" help:"Config key"`
    Value string `arg:"" help:"Config value"`
}
```

<a name="RepoConfigSetCmd.Run"></a>
### func \(\*RepoConfigSetCmd\) Run

```go
func (c *RepoConfigSetCmd) Run(g *Globals) error
```



<a name="RepoConflictsCmd"></a>
## type RepoConflictsCmd

RepoConflictsCmd groups conflict management operations.

```go
type RepoConflictsCmd struct {
    Ls      RepoConflictsLsCmd      `cmd:"" default:"1" help:"List all conflicts"`
    Show    RepoConflictsShowCmd    `cmd:"" help:"Show all versions of a conflicted file"`
    Pick    RepoConflictsPickCmd    `cmd:"" help:"Resolve by picking one version"`
    Merge   RepoConflictsMergeCmd   `cmd:"" help:"Resolve by re-merging with a different strategy"`
    Extract RepoConflictsExtractCmd `cmd:"" help:"Extract all versions to disk for manual editing"`
    Dir     string                  `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConflictsExtractCmd"></a>
## type RepoConflictsExtractCmd

RepoConflictsExtractCmd extracts all versions to disk for manual editing.

```go
type RepoConflictsExtractCmd struct {
    File string `arg:"" help:"Conflicted file to extract"`
    Dir  string `short:"d" help:"Output directory" default:"."`
}
```

<a name="RepoConflictsExtractCmd.Run"></a>
### func \(\*RepoConflictsExtractCmd\) Run

```go
func (c *RepoConflictsExtractCmd) Run(g *Globals) error
```



<a name="RepoConflictsLsCmd"></a>
## type RepoConflictsLsCmd

RepoConflictsLsCmd lists all conflicts.

```go
type RepoConflictsLsCmd struct{}
```

<a name="RepoConflictsLsCmd.Run"></a>
### func \(\*RepoConflictsLsCmd\) Run

```go
func (c *RepoConflictsLsCmd) Run(g *Globals) error
```



<a name="RepoConflictsMergeCmd"></a>
## type RepoConflictsMergeCmd

RepoConflictsMergeCmd resolves a conflict by re\-merging with a specified strategy.

```go
type RepoConflictsMergeCmd struct {
    File     string `arg:"" help:"Conflicted file to re-merge"`
    Strategy string `help:"Strategy to use" default:"three-way"`
    Dir      string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConflictsMergeCmd.Run"></a>
### func \(\*RepoConflictsMergeCmd\) Run

```go
func (c *RepoConflictsMergeCmd) Run(g *Globals) error
```



<a name="RepoConflictsPickCmd"></a>
## type RepoConflictsPickCmd

RepoConflictsPickCmd resolves a conflict by picking one version.

```go
type RepoConflictsPickCmd struct {
    File   string `arg:"" help:"Conflicted file to resolve"`
    Local  bool   `help:"Keep local version" xor:"version"`
    Remote bool   `help:"Keep remote version" xor:"version"`
    Base   bool   `help:"Revert to base version" xor:"version"`
    Dir    string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoConflictsPickCmd.Run"></a>
### func \(\*RepoConflictsPickCmd\) Run

```go
func (c *RepoConflictsPickCmd) Run(g *Globals) error
```



<a name="RepoConflictsShowCmd"></a>
## type RepoConflictsShowCmd

RepoConflictsShowCmd shows all versions of a conflicted file.

```go
type RepoConflictsShowCmd struct {
    File string `arg:"" help:"Conflicted file to show"`
}
```

<a name="RepoConflictsShowCmd.Run"></a>
### func \(\*RepoConflictsShowCmd\) Run

```go
func (c *RepoConflictsShowCmd) Run(g *Globals) error
```



<a name="RepoDeltaApplyCmd"></a>
## type RepoDeltaApplyCmd

RepoDeltaApplyCmd applies a delta to a source file.

```go
type RepoDeltaApplyCmd struct {
    Source string `arg:"" help:"Source (original) file"`
    Delta  string `arg:"" help:"Delta file"`
    Output string `short:"o" help:"Output file (default: stdout)"`
}
```

<a name="RepoDeltaApplyCmd.Run"></a>
### func \(\*RepoDeltaApplyCmd\) Run

```go
func (c *RepoDeltaApplyCmd) Run(g *Globals) error
```



<a name="RepoDeltaCmd"></a>
## type RepoDeltaCmd

RepoDeltaCmd groups delta create/apply operations.

```go
type RepoDeltaCmd struct {
    Create RepoDeltaCreateCmd `cmd:"" help:"Create a delta between two files"`
    Apply  RepoDeltaApplyCmd  `cmd:"" help:"Apply a delta to a source file"`
}
```

<a name="RepoDeltaCreateCmd"></a>
## type RepoDeltaCreateCmd

RepoDeltaCreateCmd creates a delta between two files.

```go
type RepoDeltaCreateCmd struct {
    Source string `arg:"" help:"Source (original) file"`
    Target string `arg:"" help:"Target (new) file"`
    Output string `short:"o" help:"Output file (default: stdout)"`
}
```

<a name="RepoDeltaCreateCmd.Run"></a>
### func \(\*RepoDeltaCreateCmd\) Run

```go
func (c *RepoDeltaCreateCmd) Run(g *Globals) error
```



<a name="RepoDiffCmd"></a>
## type RepoDiffCmd

RepoDiffCmd shows changes in the working directory vs a repository version, or, given two versions, the changes between them.

```go
type RepoDiffCmd struct {
    Version string `arg:"" optional:"" help:"Version to diff against (default: tip)"`
    To      string `arg:"" optional:"" help:"Second version: diff Version against it instead of the working directory"`
    Path    string `arg:"" optional:"" help:"With two versions, only this file (default: every changed file)"`
    JSON    bool   `help:"With two versions, print a JSON array of {name, unified} instead of text"`
    Dir     string `short:"d" help:"Working directory to compare" default:"."`
    Unified int    `short:"U" help:"Lines of context" default:"3"`
}
```

<a name="RepoDiffCmd.Run"></a>
### func \(\*RepoDiffCmd\) Run

```go
func (c *RepoDiffCmd) Run(g *Globals) error
```



<a name="RepoExtractCmd"></a>
## type RepoExtractCmd

RepoExtractCmd extracts files from a version.

```go
type RepoExtractCmd struct {
    Version string   `help:"Version to extract from (default: tip)"`
    Files   []string `arg:"" optional:"" help:"Files to extract (default: all)"`
    Dir     string   `short:"d" help:"Output directory" default:"."`
}
```

<a name="RepoExtractCmd.Run"></a>
### func \(\*RepoExtractCmd\) Run

```go
func (c *RepoExtractCmd) Run(g *Globals) error
```



<a name="RepoHashCmd"></a>
## type RepoHashCmd

RepoHashCmd hashes files using SHA1 or SHA3\-256.

```go
type RepoHashCmd struct {
    Files []string `arg:"" required:"" help:"Files to hash"`
    SHA3  bool     `name:"sha3" help:"Use SHA3-256 instead of SHA1"`
}
```

<a name="RepoHashCmd.Run"></a>
### func \(\*RepoHashCmd\) Run

```go
func (c *RepoHashCmd) Run(g *Globals) error
```



<a name="RepoInfoCmd"></a>
## type RepoInfoCmd

RepoInfoCmd shows repository statistics.

```go
type RepoInfoCmd struct{}
```

<a name="RepoInfoCmd.Run"></a>
### func \(\*RepoInfoCmd\) Run

```go
func (c *RepoInfoCmd) Run(g *Globals) error
```



<a name="RepoInviteCmd"></a>
## type RepoInviteCmd

RepoInviteCmd generates an invite token for a new user.

```go
type RepoInviteCmd struct {
    Login string        `arg:"" help:"Username for the invitee"`
    Cap   string        `help:"Capability string (e.g. oi)" required:""`
    URL   string        `help:"Sync URL to embed in token" default:""`
    TTL   time.Duration `help:"Token time-to-live (e.g. 24h)" default:"0"`
}
```

<a name="RepoInviteCmd.Run"></a>
### func \(\*RepoInviteCmd\) Run

```go
func (c *RepoInviteCmd) Run(g *Globals) error
```



<a name="RepoLogCmd"></a>
## type RepoLogCmd

RepoLogCmd lists the check\-ins that changed one path, newest first, as fossil finfo does.

```go
type RepoLogCmd struct {
    Path  string `required:"" help:"File name in the repository"`
    JSON  bool   `help:"Print a JSON array instead of text"`
    Limit int    `short:"n" help:"Number of entries (default: all)"`
}
```

<a name="RepoLogCmd.Run"></a>
### func \(\*RepoLogCmd\) Run

```go
func (c *RepoLogCmd) Run(g *Globals) (err error)
```



<a name="RepoLsCmd"></a>
## type RepoLsCmd

RepoLsCmd lists files in a version.

```go
type RepoLsCmd struct {
    Version string `arg:"" optional:"" help:"Version to list (default: tip)"`
    Long    bool   `short:"l" help:"Show sizes and hashes"`
}
```

<a name="RepoLsCmd.Run"></a>
### func \(\*RepoLsCmd\) Run

```go
func (c *RepoLsCmd) Run(g *Globals) error
```



<a name="RepoMergeCmd"></a>
## type RepoMergeCmd

RepoMergeCmd merges a divergent version into the current checkout. In a store with a structural horizon, a merge whose base lies below the horizon asks \-\-remote, else the saved last\-sync\-url, for the base and deepens the horizon to reach it before merging \(draft\-fossil\-horizon\-00 §5.5\).

```go
type RepoMergeCmd struct {
    RecoveryFlags
    Version  string `arg:"" help:"Version to merge into current checkout"`
    Strategy string `help:"Override merge strategy for all files"`
    DryRun   bool   `help:"Show what would be merged without writing"`
    Dir      string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoMergeCmd.Run"></a>
### func \(\*RepoMergeCmd\) Run

```go
func (c *RepoMergeCmd) Run(g *Globals) (err error)
```



<a name="RepoMergeResolveCmd"></a>
## type RepoMergeResolveCmd

RepoMergeResolveCmd marks a file conflict as resolved.

A merge conflict needs no marking: as in fossil, a file is in conflict while it holds conflict markers, and editing them out resolves it. So this command refuses a file that still holds markers, and resolves the conflict\-fork entries the conflict\-fork strategy records.

```go
type RepoMergeResolveCmd struct {
    File string `arg:"" help:"File to mark as resolved"`
    Dir  string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoMergeResolveCmd.Run"></a>
### func \(\*RepoMergeResolveCmd\) Run

```go
func (c *RepoMergeResolveCmd) Run(g *Globals) (err error)
```



<a name="RepoNewCmd"></a>
## type RepoNewCmd

RepoNewCmd creates a new Fossil repository, at Path or else at the \-R path.

```go
type RepoNewCmd struct {
    Path string `arg:"" optional:"" help:"Path for new repository file (default: -R)"`
    User string `help:"Default user name" default:""`
}
```

<a name="RepoNewCmd.Run"></a>
### func \(\*RepoNewCmd\) Run

```go
func (c *RepoNewCmd) Run(g *Globals) error
```



<a name="RepoOpenCmd"></a>
## type RepoOpenCmd

RepoOpenCmd opens a checkout in a directory, creating the .fslckout database.

```go
type RepoOpenCmd struct {
    Dir     string   `arg:"" optional:"" help:"Checkout directory (default: current dir)" default:"."`
    Cone    []string `name:"cone" help:"Make a sparse checkout: materialize and track only this path's subtree (repeatable)"`
    ConeNot []string `name:"cone-not" help:"Exclude this path's subtree from an enclosing --cone (repeatable)"`
}
```

<a name="RepoOpenCmd.Run"></a>
### func \(\*RepoOpenCmd\) Run

```go
func (c *RepoOpenCmd) Run(g *Globals) error
```



<a name="RepoQueryCmd"></a>
## type RepoQueryCmd

RepoQueryCmd executes raw SQL against the repository database.

```go
type RepoQueryCmd struct {
    SQL string `arg:"" help:"SQL query to execute"`
}
```

<a name="RepoQueryCmd.Run"></a>
### func \(\*RepoQueryCmd\) Run

```go
func (c *RepoQueryCmd) Run(g *Globals) error
```



<a name="RepoRedoCmd"></a>
## type RepoRedoCmd

RepoRedoCmd re\-applies the last undone operation.

```go
type RepoRedoCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoRedoCmd.Run"></a>
### func \(\*RepoRedoCmd\) Run

```go
func (c *RepoRedoCmd) Run(g *Globals) error
```



<a name="RepoRenameCmd"></a>
## type RepoRenameCmd

RepoRenameCmd renames a tracked file in the checkout and on disk.

```go
type RepoRenameCmd struct {
    From string `arg:"" help:"Current file name"`
    To   string `arg:"" help:"New file name"`
    Dir  string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoRenameCmd.Run"></a>
### func \(\*RepoRenameCmd\) Run

```go
func (c *RepoRenameCmd) Run(g *Globals) (err error)
```



<a name="RepoResolveCmd"></a>
## type RepoResolveCmd

RepoResolveCmd resolves a symbolic name to UUID and RID.

```go
type RepoResolveCmd struct {
    Name string `arg:"" help:"Symbolic name, UUID, or prefix to resolve (e.g. trunk, tip, UUID prefix)"`
}
```

<a name="RepoResolveCmd.Run"></a>
### func \(\*RepoResolveCmd\) Run

```go
func (c *RepoResolveCmd) Run(g *Globals) error
```



<a name="RepoRevertCmd"></a>
## type RepoRevertCmd

RepoRevertCmd restores files to their checked\-out version.

```go
type RepoRevertCmd struct {
    Files []string `arg:"" optional:"" help:"Files to revert (default: all)"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoRevertCmd.Run"></a>
### func \(\*RepoRevertCmd\) Run

```go
func (c *RepoRevertCmd) Run(g *Globals) (err error)
```



<a name="RepoRmCmd"></a>
## type RepoRmCmd

RepoRmCmd stages files for removal from the checkout.

```go
type RepoRmCmd struct {
    Files []string `arg:"" required:"" help:"Files to stage for removal"`
    Dir   string   `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoRmCmd.Run"></a>
### func \(\*RepoRmCmd\) Run

```go
func (c *RepoRmCmd) Run(g *Globals) (err error)
```



<a name="RepoSchemaAddCmd"></a>
## type RepoSchemaAddCmd

RepoSchemaAddCmd registers a new synced table.

```go
type RepoSchemaAddCmd struct {
    Name     string `arg:"" help:"Table name (without x_ prefix)"`
    Columns  string `required:"" help:"Column defs: name:type[:pk],... (e.g. peer_id:text:pk,addr:text)"`
    Conflict string `default:"mtime-wins" enum:"self-write,mtime-wins,owner-write" help:"Conflict strategy"`
}
```

<a name="RepoSchemaAddCmd.Run"></a>
### func \(\*RepoSchemaAddCmd\) Run

```go
func (c *RepoSchemaAddCmd) Run(g *Globals) error
```



<a name="RepoSchemaCmd"></a>
## type RepoSchemaCmd

RepoSchemaCmd groups synced table schema operations.

```go
type RepoSchemaCmd struct {
    Add    RepoSchemaAddCmd    `cmd:"" help:"Register a new synced table"`
    List   RepoSchemaListCmd   `cmd:"" help:"List registered synced tables"`
    Show   RepoSchemaShowCmd   `cmd:"" help:"Show table schema details"`
    Remove RepoSchemaRemoveCmd `cmd:"" help:"Remove a synced table registration"`
}
```

<a name="RepoSchemaListCmd"></a>
## type RepoSchemaListCmd

RepoSchemaListCmd lists registered synced tables.

```go
type RepoSchemaListCmd struct{}
```

<a name="RepoSchemaListCmd.Run"></a>
### func \(\*RepoSchemaListCmd\) Run

```go
func (c *RepoSchemaListCmd) Run(g *Globals) error
```



<a name="RepoSchemaRemoveCmd"></a>
## type RepoSchemaRemoveCmd

RepoSchemaRemoveCmd removes a synced table registration.

```go
type RepoSchemaRemoveCmd struct {
    Name string `arg:"" help:"Table name (without x_ prefix)"`
}
```

<a name="RepoSchemaRemoveCmd.Run"></a>
### func \(\*RepoSchemaRemoveCmd\) Run

```go
func (c *RepoSchemaRemoveCmd) Run(g *Globals) error
```



<a name="RepoSchemaShowCmd"></a>
## type RepoSchemaShowCmd

RepoSchemaShowCmd shows table schema details.

```go
type RepoSchemaShowCmd struct {
    Name string `arg:"" help:"Table name (without x_ prefix)"`
}
```

<a name="RepoSchemaShowCmd.Run"></a>
### func \(\*RepoSchemaShowCmd\) Run

```go
func (c *RepoSchemaShowCmd) Run(g *Globals) error
```



<a name="RepoServeCmd"></a>
## type RepoServeCmd

RepoServeCmd starts an HTTP xfer server for the repository so a remote fossil client \-\- the canonical binary or another instance of this tool \-\- can clone or sync against it. This is a thin wrapper: all serving logic lives in Repo.ServeHTTP; the command's job is to open the repo, resolve the bind address, and translate process interrupt into the context cancellation that ServeHTTP already honors. Access follows the user table, as with fossil serve: clients without credentials act as nobody, which may clone and pull a new repository but not push to it. A repository with a store cone refuses clones its cone does not cover unless \`repo config set partial\-mirror on\` marks it a partial mirror.

```go
type RepoServeCmd struct {
    Addr string `short:"P" default:"127.0.0.1:8080" help:"Bind address as host:port"`
}
```

<a name="RepoServeCmd.Run"></a>
### func \(\*RepoServeCmd\) Run

```go
func (c *RepoServeCmd) Run(g *Globals) error
```



<a name="RepoSnapshotCmd"></a>
## type RepoSnapshotCmd

RepoSnapshotCmd commits the bytes of one file onto trunk without a checkout: the tip's other files carry forward, and bytes equal to the tip's are a no\-op that prints the existing tip.

```go
type RepoSnapshotCmd struct {
    Message string `short:"m" required:"" help:"Checkin comment"`
    Path    string `required:"" help:"File name in the repository (relative, slash-separated); the bytes come from this path on disk unless --stdin"`
    Stdin   bool   `help:"Read the bytes from stdin instead of from --path on disk"`
    User    string `help:"Checkin user (default: OS username)"`
    JSON    bool   `help:"Print {\"uuid\":...,\"changed\":...} instead of the bare uuid"`
}
```

<a name="RepoSnapshotCmd.Run"></a>
### func \(\*RepoSnapshotCmd\) Run

```go
func (c *RepoSnapshotCmd) Run(g *Globals) (err error)
```



<a name="RepoStashApplyCmd"></a>
## type RepoStashApplyCmd

RepoStashApplyCmd applies a stash entry without removing it.

```go
type RepoStashApplyCmd struct {
    ID  int64  `arg:"" optional:"" help:"Stash ID to apply (default: latest)"`
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoStashApplyCmd.Run"></a>
### func \(\*RepoStashApplyCmd\) Run

```go
func (c *RepoStashApplyCmd) Run(g *Globals) error
```



<a name="RepoStashClearCmd"></a>
## type RepoStashClearCmd

RepoStashClearCmd removes all stash entries.

```go
type RepoStashClearCmd struct{}
```

<a name="RepoStashClearCmd.Run"></a>
### func \(\*RepoStashClearCmd\) Run

```go
func (c *RepoStashClearCmd) Run(g *Globals) error
```



<a name="RepoStashCmd"></a>
## type RepoStashCmd

RepoStashCmd groups stash operations.

```go
type RepoStashCmd struct {
    Save  RepoStashSaveCmd  `cmd:"" help:"Stash working changes"`
    Pop   RepoStashPopCmd   `cmd:"" help:"Apply top stash and drop it"`
    Apply RepoStashApplyCmd `cmd:"" help:"Apply stash without dropping"`
    Ls    RepoStashLsCmd    `cmd:"" help:"List stash entries"`
    Drop  RepoStashDropCmd  `cmd:"" help:"Remove stash entry"`
    Clear RepoStashClearCmd `cmd:"" help:"Remove all stash entries"`
}
```

<a name="RepoStashDropCmd"></a>
## type RepoStashDropCmd

RepoStashDropCmd removes a stash entry by ID.

```go
type RepoStashDropCmd struct {
    ID int64 `arg:"" required:"" help:"Stash ID to drop"`
}
```

<a name="RepoStashDropCmd.Run"></a>
### func \(\*RepoStashDropCmd\) Run

```go
func (c *RepoStashDropCmd) Run(g *Globals) error
```



<a name="RepoStashLsCmd"></a>
## type RepoStashLsCmd

RepoStashLsCmd lists stash entries.

```go
type RepoStashLsCmd struct{}
```

<a name="RepoStashLsCmd.Run"></a>
### func \(\*RepoStashLsCmd\) Run

```go
func (c *RepoStashLsCmd) Run(g *Globals) error
```



<a name="RepoStashPopCmd"></a>
## type RepoStashPopCmd

RepoStashPopCmd pops the top stash entry.

```go
type RepoStashPopCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoStashPopCmd.Run"></a>
### func \(\*RepoStashPopCmd\) Run

```go
func (c *RepoStashPopCmd) Run(g *Globals) error
```



<a name="RepoStashSaveCmd"></a>
## type RepoStashSaveCmd

RepoStashSaveCmd saves working changes to the stash.

```go
type RepoStashSaveCmd struct {
    Message string `short:"m" help:"Stash message" default:""`
    Dir     string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoStashSaveCmd.Run"></a>
### func \(\*RepoStashSaveCmd\) Run

```go
func (c *RepoStashSaveCmd) Run(g *Globals) error
```



<a name="RepoStatusCmd"></a>
## type RepoStatusCmd

RepoStatusCmd shows the checkout's changes against its checked\-out version.

```go
type RepoStatusCmd struct {
    Dir string `short:"d" help:"Checkout directory to scan" default:"."`
}
```

<a name="RepoStatusCmd.Run"></a>
### func \(\*RepoStatusCmd\) Run

```go
func (c *RepoStatusCmd) Run(g *Globals) error
```



<a name="RepoSubmanifestsCmd"></a>
## type RepoSubmanifestsCmd

RepoSubmanifestsCmd groups the sub\-manifest settings \(draft\-fossil\-submanifests\-00\): whether new check\-ins are written as trees, and the partition parameter k they are built with.

```go
type RepoSubmanifestsCmd struct {
    Enable  RepoSubmanifestsEnableCmd  `cmd:"" help:"Write new check-ins as sub-manifest trees"`
    Retune  RepoSubmanifestsRetuneCmd  `cmd:"" help:"Re-pin the partition parameter for later commits"`
    Disable RepoSubmanifestsDisableCmd `cmd:"" help:"Write new check-ins as flat manifests again"`
    Status  RepoSubmanifestsStatusCmd  `cmd:"" help:"Show the sub-manifest settings and whether trees exist"`
}
```

<a name="RepoSubmanifestsDisableCmd"></a>
## type RepoSubmanifestsDisableCmd

RepoSubmanifestsDisableCmd turns tree emission off; existing trees stay.

```go
type RepoSubmanifestsDisableCmd struct{}
```

<a name="RepoSubmanifestsDisableCmd.Run"></a>
### func \(\*RepoSubmanifestsDisableCmd\) Run

```go
func (c *RepoSubmanifestsDisableCmd) Run(g *Globals) error
```



<a name="RepoSubmanifestsEnableCmd"></a>
## type RepoSubmanifestsEnableCmd

RepoSubmanifestsEnableCmd turns tree emission on, pinning k the first time.

```go
type RepoSubmanifestsEnableCmd struct {
    K *int `name:"k" help:"Partition parameter, 1..12 (default: selected from the main-branch tip)"`
}
```

<a name="RepoSubmanifestsEnableCmd.Run"></a>
### func \(\*RepoSubmanifestsEnableCmd\) Run

```go
func (c *RepoSubmanifestsEnableCmd) Run(g *Globals) error
```



<a name="RepoSubmanifestsRetuneCmd"></a>
## type RepoSubmanifestsRetuneCmd

RepoSubmanifestsRetuneCmd re\-pins k; a re\-tune is always explicit.

```go
type RepoSubmanifestsRetuneCmd struct {
    K int `name:"k" required:"" help:"New partition parameter, 1..12"`
}
```

<a name="RepoSubmanifestsRetuneCmd.Run"></a>
### func \(\*RepoSubmanifestsRetuneCmd\) Run

```go
func (c *RepoSubmanifestsRetuneCmd) Run(g *Globals) error
```



<a name="RepoSubmanifestsStatusCmd"></a>
## type RepoSubmanifestsStatusCmd

RepoSubmanifestsStatusCmd prints the three settings and whether the repository holds any S\-bearing artifact.

```go
type RepoSubmanifestsStatusCmd struct{}
```

<a name="RepoSubmanifestsStatusCmd.Run"></a>
### func \(\*RepoSubmanifestsStatusCmd\) Run

```go
func (c *RepoSubmanifestsStatusCmd) Run(g *Globals) error
```



<a name="RepoTagAddCmd"></a>
## type RepoTagAddCmd

RepoTagAddCmd adds a tag to an artifact.

```go
type RepoTagAddCmd struct {
    Tag     string `arg:"" help:"Tag name"`
    Value   string `arg:"" optional:"" help:"Tag value (optional)"`
    Version string `help:"Version to tag (default: tip)"`
}
```

<a name="RepoTagAddCmd.Run"></a>
### func \(\*RepoTagAddCmd\) Run

```go
func (c *RepoTagAddCmd) Run(g *Globals) error
```



<a name="RepoTagCmd"></a>
## type RepoTagCmd

RepoTagCmd groups tag operations.

```go
type RepoTagCmd struct {
    Ls  RepoTagLsCmd  `cmd:"" help:"List tags on an artifact"`
    Add RepoTagAddCmd `cmd:"" help:"Add a tag to an artifact"`
}
```

<a name="RepoTagLsCmd"></a>
## type RepoTagLsCmd

RepoTagLsCmd lists tags on an artifact.

```go
type RepoTagLsCmd struct {
    Version string `arg:"" optional:"" help:"Version to list tags for (default: tip)"`
}
```

<a name="RepoTagLsCmd.Run"></a>
### func \(\*RepoTagLsCmd\) Run

```go
func (c *RepoTagLsCmd) Run(g *Globals) error
```



<a name="RepoTimelineCmd"></a>
## type RepoTimelineCmd

RepoTimelineCmd shows repository timeline/history.

```go
type RepoTimelineCmd struct {
    Limit int `short:"n" default:"20" help:"Number of entries"`
}
```

<a name="RepoTimelineCmd.Run"></a>
### func \(\*RepoTimelineCmd\) Run

```go
func (c *RepoTimelineCmd) Run(g *Globals) error
```



<a name="RepoUVCmd"></a>
## type RepoUVCmd

RepoUVCmd groups unversioned file operations.

```go
type RepoUVCmd struct {
    Ls     RepoUVLsCmd     `cmd:"" help:"List unversioned files"`
    Put    RepoUVPutCmd    `cmd:"" help:"Add or update an unversioned file"`
    Get    RepoUVGetCmd    `cmd:"" help:"Retrieve an unversioned file"`
    Delete RepoUVDeleteCmd `cmd:"" help:"Delete an unversioned file (creates tombstone)"`
}
```

<a name="RepoUVDeleteCmd"></a>
## type RepoUVDeleteCmd

RepoUVDeleteCmd deletes an unversioned file \(creates a tombstone\).

```go
type RepoUVDeleteCmd struct {
    Name string `arg:"" help:"Name of the unversioned file to delete"`
}
```

<a name="RepoUVDeleteCmd.Run"></a>
### func \(\*RepoUVDeleteCmd\) Run

```go
func (c *RepoUVDeleteCmd) Run(g *Globals) error
```



<a name="RepoUVGetCmd"></a>
## type RepoUVGetCmd

RepoUVGetCmd retrieves an unversioned file.

```go
type RepoUVGetCmd struct {
    Name   string `arg:"" help:"Name of the unversioned file"`
    Output string `short:"o" help:"Output file (default: stdout)"`
}
```

<a name="RepoUVGetCmd.Run"></a>
### func \(\*RepoUVGetCmd\) Run

```go
func (c *RepoUVGetCmd) Run(g *Globals) error
```



<a name="RepoUVLsCmd"></a>
## type RepoUVLsCmd

RepoUVLsCmd lists unversioned files.

```go
type RepoUVLsCmd struct{}
```

<a name="RepoUVLsCmd.Run"></a>
### func \(\*RepoUVLsCmd\) Run

```go
func (c *RepoUVLsCmd) Run(g *Globals) error
```



<a name="RepoUVPutCmd"></a>
## type RepoUVPutCmd

RepoUVPutCmd adds or updates an unversioned file.

```go
type RepoUVPutCmd struct {
    Name string `arg:"" help:"Name of the unversioned file"`
    File string `arg:"" help:"Local file to upload"`
}
```

<a name="RepoUVPutCmd.Run"></a>
### func \(\*RepoUVPutCmd\) Run

```go
func (c *RepoUVPutCmd) Run(g *Globals) error
```



<a name="RepoUndoCmd"></a>
## type RepoUndoCmd

RepoUndoCmd undoes the last checkout operation.

```go
type RepoUndoCmd struct {
    Dir string `short:"d" help:"Checkout directory" default:"."`
}
```

<a name="RepoUndoCmd.Run"></a>
### func \(\*RepoUndoCmd\) Run

```go
func (c *RepoUndoCmd) Run(g *Globals) error
```



<a name="RepoUserCmd"></a>
## type RepoUserCmd

RepoUserCmd groups user management operations.

```go
type RepoUserCmd struct {
    Add    UserAddCmd    `cmd:"" help:"Create a new user"`
    List   UserListCmd   `cmd:"" help:"List all users"`
    Update UserUpdateCmd `cmd:"" help:"Update user capabilities"`
    Rm     UserRmCmd     `cmd:"" help:"Delete a user"`
    Passwd UserPasswdCmd `cmd:"" help:"Reset user password"`
}
```

<a name="RepoVerifyCmd"></a>
## type RepoVerifyCmd

RepoVerifyCmd verifies repository integrity: every held artifact against its name, delta chains, phantom records and the derived tables. It reports what the store lacks by class \(sparse\-cone §5.2\): transit phantoms, which sync still wants, apart from artifacts the store cone deliberately elides, which are healthy and never an error.

\-\-seed first verifies a structural store's seed by deepening \(draft\-fossil\-horizon\-00 §5.9\): the history below the horizon is fetched from \-\-remote, else the saved last\-sync\-url, and what it derives is compared with what the seed asserted. The store is left a content\-horizon store, which holds no seed.

```go
type RepoVerifyCmd struct {
    RecoveryFlags
    Seed bool `help:"Verify the structural horizon's seed by fetching the history below it (keeps the content horizon)"`
}
```

<a name="RepoVerifyCmd.Run"></a>
### func \(\*RepoVerifyCmd\) Run

```go
func (c *RepoVerifyCmd) Run(g *Globals) error
```



<a name="RepoWikiCmd"></a>
## type RepoWikiCmd

RepoWikiCmd groups wiki operations.

```go
type RepoWikiCmd struct {
    Ls     RepoWikiLsCmd     `cmd:"" help:"List wiki pages"`
    Export RepoWikiExportCmd `cmd:"" help:"Export a wiki page"`
}
```

<a name="RepoWikiExportCmd"></a>
## type RepoWikiExportCmd

RepoWikiExportCmd exports a wiki page.

```go
type RepoWikiExportCmd struct {
    Page   string `arg:"" help:"Wiki page name or artifact UUID"`
    Output string `short:"o" help:"Output file (default: stdout)"`
}
```

<a name="RepoWikiExportCmd.Run"></a>
### func \(\*RepoWikiExportCmd\) Run

```go
func (c *RepoWikiExportCmd) Run(g *Globals) error
```



<a name="RepoWikiLsCmd"></a>
## type RepoWikiLsCmd

RepoWikiLsCmd lists wiki pages.

```go
type RepoWikiLsCmd struct{}
```

<a name="RepoWikiLsCmd.Run"></a>
### func \(\*RepoWikiLsCmd\) Run

```go
func (c *RepoWikiLsCmd) Run(g *Globals) error
```



<a name="UserAddCmd"></a>
## type UserAddCmd

UserAddCmd creates a new user.

```go
type UserAddCmd struct {
    Login string `arg:"" help:"Username"`
    Cap   string `help:"Capability string (e.g. oi)" required:""`
}
```

<a name="UserAddCmd.Run"></a>
### func \(\*UserAddCmd\) Run

```go
func (c *UserAddCmd) Run(g *Globals) error
```



<a name="UserListCmd"></a>
## type UserListCmd

UserListCmd lists all users.

```go
type UserListCmd struct{}
```

<a name="UserListCmd.Run"></a>
### func \(\*UserListCmd\) Run

```go
func (c *UserListCmd) Run(g *Globals) error
```



<a name="UserPasswdCmd"></a>
## type UserPasswdCmd

UserPasswdCmd resets a user's password.

```go
type UserPasswdCmd struct {
    Login string `arg:"" help:"Username"`
}
```

<a name="UserPasswdCmd.Run"></a>
### func \(\*UserPasswdCmd\) Run

```go
func (c *UserPasswdCmd) Run(g *Globals) error
```



<a name="UserRmCmd"></a>
## type UserRmCmd

UserRmCmd deletes a user.

```go
type UserRmCmd struct {
    Login string `arg:"" help:"Username"`
}
```

<a name="UserRmCmd.Run"></a>
### func \(\*UserRmCmd\) Run

```go
func (c *UserRmCmd) Run(g *Globals) error
```



<a name="UserUpdateCmd"></a>
## type UserUpdateCmd

UserUpdateCmd updates user capabilities.

```go
type UserUpdateCmd struct {
    Login string `arg:"" help:"Username"`
    Cap   string `help:"New capability string" required:""`
}
```

<a name="UserUpdateCmd.Run"></a>
### func \(\*UserUpdateCmd\) Run

```go
func (c *UserUpdateCmd) Run(g *Globals) error
```



<a name="VersionCmd"></a>
## type VersionCmd

VersionCmd prints a single\-line, stable, machine\-parseable build identifier and exits 0.

```go
type VersionCmd struct{}
```

<a name="VersionCmd.Run"></a>
### func \(\*VersionCmd\) Run

```go
func (c *VersionCmd) Run() error
```

Run prints Version\(\) and always succeeds: there is nothing about the local environment that can make reporting the build identifier fail.

Generated by [gomarkdoc](<https://github.com/princjef/gomarkdoc>)