Help us shape the future of Go! Take the 2026 Go Developer Survey

cli

package
v0.17.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 31, 2026 License: MIT Imports: 42 Imported by: 0

Documentation

Index

Constants

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

Exit statuses the machine-facing commands (snapshot, log, cat --at, diff) document and keep stable. Every other failure, including a usage error, is ExitFailure.

Variables

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

ErrConeTestElided is what `repo cone test` returns when any path it was given is outside the cone, so the command works as a predicate.

Functions

func Version

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.

Types

type ExitError added in v0.13.0

type ExitError struct {
	Code int
	Err  error
}

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

func (*ExitError) Error added in v0.13.0

func (e *ExitError) Error() string

func (*ExitError) Unwrap added in v0.13.0

func (e *ExitError) Unwrap() error

type Globals

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

Globals holds flags shared by all CLI commands.

func (*Globals) OpenRepo

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.

type RecoveryFlags added in v0.14.0

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

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

type RepoAddCmd

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

RepoAddCmd stages files for addition in the checkout database.

func (*RepoAddCmd) Run

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

type RepoAnnotateCmd

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

RepoAnnotateCmd annotates file lines with version history.

func (*RepoAnnotateCmd) Run

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

type RepoBisectBadCmd

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

RepoBisectBadCmd marks a version as bad.

func (*RepoBisectBadCmd) Run

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

type RepoBisectCmd

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

RepoBisectCmd groups binary search operations.

type RepoBisectGoodCmd

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

RepoBisectGoodCmd marks a version as good.

func (*RepoBisectGoodCmd) Run

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

type RepoBisectLsCmd

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

RepoBisectLsCmd shows the bisect path.

func (*RepoBisectLsCmd) Run

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

type RepoBisectNextCmd

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

RepoBisectNextCmd checks out the bisect midpoint version.

func (*RepoBisectNextCmd) Run

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

type RepoBisectResetCmd

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

RepoBisectResetCmd clears bisect state.

func (*RepoBisectResetCmd) Run

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

type RepoBisectSkipCmd

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

RepoBisectSkipCmd skips the current version.

func (*RepoBisectSkipCmd) Run

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

type RepoBisectStatusCmd

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

RepoBisectStatusCmd shows bisect state.

func (*RepoBisectStatusCmd) Run

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

type RepoBlameCmd

type RepoBlameCmd struct {
	RepoAnnotateCmd
}

RepoBlameCmd is an alias for annotate.

type RepoBranchCloseCmd

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

RepoBranchCloseCmd closes a branch.

func (*RepoBranchCloseCmd) Run

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

type RepoBranchCmd

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

RepoBranchCmd groups branch operations.

type RepoBranchLsCmd

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

RepoBranchLsCmd lists branches.

func (*RepoBranchLsCmd) Run

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

type RepoBranchNewCmd

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

RepoBranchNewCmd creates a new branch.

func (*RepoBranchNewCmd) Run

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

type RepoCatCmd

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

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.

func (*RepoCatCmd) Run

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

type RepoCiCmd

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

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.

func (*RepoCiCmd) Run

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

type RepoCloneCmd

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        `` /* 362-byte string literal not displayed */
	Depth      int           `help:"With --horizon, step the check-in back this many check-ins along primary parents, stopping at a root"`
	Leaves     bool          `` /* 207-byte string literal not displayed */
	Structural bool          `` /* 126-byte string literal not displayed */
	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        `` /* 247-byte string literal not displayed */
}

RepoCloneCmd clones a remote Fossil repository.

func (*RepoCloneCmd) Run

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

type RepoCmd

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

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

type RepoCoCmd

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

RepoCoCmd checks out a version to the working directory.

func (*RepoCoCmd) Run

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

type RepoConeAddCmd added in v0.14.0

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

RepoConeAddCmd adds members to the cone.

func (*RepoConeAddCmd) Run added in v0.14.0

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

type RepoConeCmd added in v0.14.0

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

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.

type RepoConeCompactCmd added in v0.14.0

type RepoConeCompactCmd struct{}

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.

func (*RepoConeCompactCmd) Run added in v0.14.0

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

type RepoConeCostCmd added in v0.15.0

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

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.

func (*RepoConeCostCmd) Run added in v0.15.0

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

type RepoConeDeepenCmd added in v0.15.0

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

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.

func (*RepoConeDeepenCmd) Run added in v0.15.0

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

type RepoConeDenseCmd added in v0.14.0

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

RepoConeDenseCmd drops the cone.

func (*RepoConeDenseCmd) Run added in v0.14.0

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

type RepoConeRemoveCmd added in v0.14.0

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

RepoConeRemoveCmd removes members from the cone.

func (*RepoConeRemoveCmd) Run added in v0.14.0

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

type RepoConeSetCmd added in v0.14.0

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

RepoConeSetCmd replaces the cone.

func (*RepoConeSetCmd) Run added in v0.14.0

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

type RepoConeShowCmd added in v0.14.0

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

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

func (*RepoConeShowCmd) Run added in v0.14.0

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

type RepoConeStoreCmd added in v0.14.0

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   `` /* 156-byte string literal not displayed */
	Leaves     bool     `` /* 207-byte string literal not displayed */
	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"`
}

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.

func (*RepoConeStoreCmd) Run added in v0.14.0

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

type RepoConeTestCmd added in v0.14.0

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

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

func (*RepoConeTestCmd) Run added in v0.14.0

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

type RepoConfigCmd

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

RepoConfigCmd groups configuration operations.

type RepoConfigGetCmd

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

RepoConfigGetCmd gets a single config value.

func (*RepoConfigGetCmd) Run

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

type RepoConfigLsCmd

type RepoConfigLsCmd struct{}

RepoConfigLsCmd lists all config entries.

func (*RepoConfigLsCmd) Run

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

type RepoConfigSetCmd

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

RepoConfigSetCmd sets a config value.

func (*RepoConfigSetCmd) Run

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

type RepoConflictsCmd

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

RepoConflictsCmd groups conflict management operations.

type RepoConflictsExtractCmd

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

RepoConflictsExtractCmd extracts all versions to disk for manual editing.

func (*RepoConflictsExtractCmd) Run

type RepoConflictsLsCmd

type RepoConflictsLsCmd struct{}

RepoConflictsLsCmd lists all conflicts.

func (*RepoConflictsLsCmd) Run

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

type RepoConflictsMergeCmd

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

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

func (*RepoConflictsMergeCmd) Run

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

type RepoConflictsPickCmd

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

RepoConflictsPickCmd resolves a conflict by picking one version.

func (*RepoConflictsPickCmd) Run

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

type RepoConflictsShowCmd

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

RepoConflictsShowCmd shows all versions of a conflicted file.

func (*RepoConflictsShowCmd) Run

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

type RepoDeltaApplyCmd

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

RepoDeltaApplyCmd applies a delta to a source file.

func (*RepoDeltaApplyCmd) Run

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

type RepoDeltaCmd

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

RepoDeltaCmd groups delta create/apply operations.

type RepoDeltaCreateCmd

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

RepoDeltaCreateCmd creates a delta between two files.

func (*RepoDeltaCreateCmd) Run

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

type RepoDiffCmd

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

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

func (*RepoDiffCmd) Run

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

type RepoExtractCmd

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

RepoExtractCmd extracts files from a version.

func (*RepoExtractCmd) Run

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

type RepoHashCmd

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

RepoHashCmd hashes files using SHA1 or SHA3-256.

func (*RepoHashCmd) Run

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

type RepoInfoCmd

type RepoInfoCmd struct{}

RepoInfoCmd shows repository statistics.

func (*RepoInfoCmd) Run

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

type RepoInviteCmd

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

RepoInviteCmd generates an invite token for a new user.

func (*RepoInviteCmd) Run

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

type RepoLogCmd added in v0.13.0

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

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

func (*RepoLogCmd) Run added in v0.13.0

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

type RepoLsCmd

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

RepoLsCmd lists files in a version.

func (*RepoLsCmd) Run

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

type RepoMergeCmd

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

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

func (*RepoMergeCmd) Run

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

type RepoMergeResolveCmd

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

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.

func (*RepoMergeResolveCmd) Run

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

type RepoNewCmd

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

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

func (*RepoNewCmd) Run

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

type RepoOpenCmd

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

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

func (*RepoOpenCmd) Run

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

type RepoQueryCmd

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

RepoQueryCmd executes raw SQL against the repository database.

func (*RepoQueryCmd) Run

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

type RepoRedoCmd

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

RepoRedoCmd re-applies the last undone operation.

func (*RepoRedoCmd) Run

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

type RepoRenameCmd

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

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

func (*RepoRenameCmd) Run

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

type RepoResolveCmd

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

RepoResolveCmd resolves a symbolic name to UUID and RID.

func (*RepoResolveCmd) Run

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

type RepoRevertCmd

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

RepoRevertCmd restores files to their checked-out version.

func (*RepoRevertCmd) Run

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

type RepoRmCmd

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

RepoRmCmd stages files for removal from the checkout.

func (*RepoRmCmd) Run

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

type RepoSchemaAddCmd

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

RepoSchemaAddCmd registers a new synced table.

func (*RepoSchemaAddCmd) Run

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

type RepoSchemaCmd

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

RepoSchemaCmd groups synced table schema operations.

type RepoSchemaListCmd

type RepoSchemaListCmd struct{}

RepoSchemaListCmd lists registered synced tables.

func (*RepoSchemaListCmd) Run

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

type RepoSchemaRemoveCmd

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

RepoSchemaRemoveCmd removes a synced table registration.

func (*RepoSchemaRemoveCmd) Run

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

type RepoSchemaShowCmd

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

RepoSchemaShowCmd shows table schema details.

func (*RepoSchemaShowCmd) Run

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

type RepoServeCmd

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

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.

func (*RepoServeCmd) Run

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

type RepoSnapshotCmd added in v0.13.0

type RepoSnapshotCmd struct {
	Message string `short:"m" required:"" help:"Checkin comment"`
	Path    string `` /* 128-byte string literal not displayed */
	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"`
}

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.

func (*RepoSnapshotCmd) Run added in v0.13.0

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

type RepoStashApplyCmd

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

RepoStashApplyCmd applies a stash entry without removing it.

func (*RepoStashApplyCmd) Run

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

type RepoStashClearCmd

type RepoStashClearCmd struct{}

RepoStashClearCmd removes all stash entries.

func (*RepoStashClearCmd) Run

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

type RepoStashCmd

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

RepoStashCmd groups stash operations.

type RepoStashDropCmd

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

RepoStashDropCmd removes a stash entry by ID.

func (*RepoStashDropCmd) Run

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

type RepoStashLsCmd

type RepoStashLsCmd struct{}

RepoStashLsCmd lists stash entries.

func (*RepoStashLsCmd) Run

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

type RepoStashPopCmd

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

RepoStashPopCmd pops the top stash entry.

func (*RepoStashPopCmd) Run

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

type RepoStashSaveCmd

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

RepoStashSaveCmd saves working changes to the stash.

func (*RepoStashSaveCmd) Run

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

type RepoStatusCmd

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

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

func (*RepoStatusCmd) Run

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

type RepoSubmanifestsCmd added in v0.14.0

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

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.

type RepoSubmanifestsDisableCmd added in v0.14.0

type RepoSubmanifestsDisableCmd struct{}

RepoSubmanifestsDisableCmd turns tree emission off; existing trees stay.

func (*RepoSubmanifestsDisableCmd) Run added in v0.14.0

type RepoSubmanifestsEnableCmd added in v0.14.0

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

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

func (*RepoSubmanifestsEnableCmd) Run added in v0.14.0

type RepoSubmanifestsRetuneCmd added in v0.14.0

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

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

func (*RepoSubmanifestsRetuneCmd) Run added in v0.14.0

type RepoSubmanifestsStatusCmd added in v0.14.0

type RepoSubmanifestsStatusCmd struct{}

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

func (*RepoSubmanifestsStatusCmd) Run added in v0.14.0

type RepoTagAddCmd

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

RepoTagAddCmd adds a tag to an artifact.

func (*RepoTagAddCmd) Run

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

type RepoTagCmd

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

RepoTagCmd groups tag operations.

type RepoTagLsCmd

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

RepoTagLsCmd lists tags on an artifact.

func (*RepoTagLsCmd) Run

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

type RepoTimelineCmd

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

RepoTimelineCmd shows repository timeline/history.

func (*RepoTimelineCmd) Run

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

type RepoUVCmd

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

RepoUVCmd groups unversioned file operations.

type RepoUVDeleteCmd

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

RepoUVDeleteCmd deletes an unversioned file (creates a tombstone).

func (*RepoUVDeleteCmd) Run

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

type RepoUVGetCmd

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

RepoUVGetCmd retrieves an unversioned file.

func (*RepoUVGetCmd) Run

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

type RepoUVLsCmd

type RepoUVLsCmd struct{}

RepoUVLsCmd lists unversioned files.

func (*RepoUVLsCmd) Run

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

type RepoUVPutCmd

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

RepoUVPutCmd adds or updates an unversioned file.

func (*RepoUVPutCmd) Run

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

type RepoUndoCmd

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

RepoUndoCmd undoes the last checkout operation.

func (*RepoUndoCmd) Run

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

type RepoUserCmd

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

RepoUserCmd groups user management operations.

type RepoVerifyCmd

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

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.

func (*RepoVerifyCmd) Run

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

type RepoWikiCmd

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

RepoWikiCmd groups wiki operations.

type RepoWikiExportCmd

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

RepoWikiExportCmd exports a wiki page.

func (*RepoWikiExportCmd) Run

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

type RepoWikiLsCmd

type RepoWikiLsCmd struct{}

RepoWikiLsCmd lists wiki pages.

func (*RepoWikiLsCmd) Run

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

type UserAddCmd

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

UserAddCmd creates a new user.

func (*UserAddCmd) Run

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

type UserListCmd

type UserListCmd struct{}

UserListCmd lists all users.

func (*UserListCmd) Run

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

type UserPasswdCmd

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

UserPasswdCmd resets a user's password.

func (*UserPasswdCmd) Run

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

type UserRmCmd

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

UserRmCmd deletes a user.

func (*UserRmCmd) Run

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

type UserUpdateCmd

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

UserUpdateCmd updates user capabilities.

func (*UserUpdateCmd) Run

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

type VersionCmd

type VersionCmd struct{}

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

func (*VersionCmd) Run

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL