Artifact [cd2cc08e57]

Artifact cd2cc08e57bc7720ed94592dfa94f00c52381caaaa412cf4c891b80e3af756ce:

• File docs/site/content/docs/reference/sdk/cli/api.md — part of check-in [5377023003] at 2026-10-18 17:04:24 on branch feat/submanifest-reader — feat: select over the main-branch tip, and add submanifests status

  Repo.EnableSubmanifests(k) now analyzes the current trunk, the check-in the next commit most plausibly descends from, instead of the newest check-in; with no trunk check-in only an explicit k succeeds. A test puts a newer one-file check-in on another branch to show which one is read. Repo.DisableSubmanifests returns only an error and documents that existing trees stay.

  `libfossil repo submanifests status` prints the three settings and whether the repository holds a tree; `retune` requires --k, and `disable` prints zit's note when trees exist. The SDK pages are rebuilt with make docs-gen-sdk. (user: [email protected], size: 51361) [annotate] [blame] [check-ins using]

---
title: cli
---

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

# cli

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

## Index

- [func Version\(\) string](<#Version>)
- [type Globals](<#Globals>)
  - [func \(g \*Globals\) OpenRepo\(\) \(\*libfossil.Repo, error\)](<#Globals.OpenRepo>)
- [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 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 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 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>)


<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="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 .fslckout checkout.

<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)"`
}
```

<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.

```go
type RepoCatCmd struct {
    Artifact string `arg:"" help:"Artifact 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 {
    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"`
    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"`
}
```

<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"`
    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"`
}
```

<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="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.

```go
type RepoDiffCmd struct {
    Version string `arg:"" optional:"" help:"Version to diff against (default: tip)"`
    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="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.

```go
type RepoMergeCmd struct {
    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.

```go
type RepoNewCmd struct {
    Path string `arg:"" help:"Path for new repository file"`
    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:"."`
}
```

<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.

```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="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 working directory changes vs the tip 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.

```go
type RepoVerifyCmd struct{}
```

<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>)