pkgmanager

type Env ¶

type Env struct {
	Root    string
	Fetcher Fetcher
	Logf    func(format string, args ...any)
}

Env carries everything the commands operate on: the project root (where the manifest, lockfile, and lua_modules/ live), the Fetcher to clone with, and an optional progress logger. A zero Logf means silent.

func (e *Env) Add(specStr, name string) error

func (e *Env) Install() error

func (e *Env) Remove(name string) error

type Fetcher ¶

type Fetcher interface {
	Fetch(spec Spec, destDir string) (commit string, err error)
}

Fetcher clones a package's source into destDir and reports the exact commit it landed on. destDir must not already exist; the fetcher creates it. The interface exists so command orchestration can be tested without a network or a git binary (see fakeFetcher in the tests).

type GitFetcher ¶

type GitFetcher struct{}

GitFetcher fetches by shelling out to the system `git`. It clones over https, checks out the requested ref, records HEAD, then deletes the `.git` directory so installed packages are plain source trees (smaller, and no nested-repo surprises for the consuming project's own VCS).

func (GitFetcher) Fetch(spec Spec, destDir string) (string, error)

type Lock ¶

type Lock struct {
	Packages map[string]LockEntry `json:"packages"`
}

Lock is the parsed `luascript-lock.json`. It records, per installed package name, exactly what was fetched so a later `install` reproduces the same bytes regardless of where the upstream ref now points.

func LoadLock(path string) (*Lock, error)

func (l *Lock) Save(path string) error

type LockEntry ¶

type LockEntry struct {
	Source string `json:"source"`
	Ref    string `json:"ref,omitempty"`
	URL    string `json:"url"`
	Commit string `json:"commit"`
}

LockEntry is one resolved dependency. Source is the `host/path` (no ref), Ref is the tag/branch/commit the user asked for ("" = default branch), URL is the clone URL git was given, and Commit is the exact resolved hash.

type Manifest ¶

type Manifest struct {
	Name         string            `json:"name"`
	Version      string            `json:"version"`
	Dependencies map[string]string `json:"dependencies"`
}

Manifest is the parsed `luascript.json`. Dependencies maps a local package name (the name used in `require`) to a source spec of the form `host/path[@ref]` — e.g. "github.com/alice/router@v1.2.0".

func LoadManifest(path string) (*Manifest, bool, error)

func (m *Manifest) Save(path string) error

type Spec ¶

type Spec struct {
	Source string // host/path, no scheme, no ref
	Ref    string // tag/branch/commit, or "" for the default branch
}

Spec is a parsed dependency source: a `host/path` with an optional ref (tag, branch, or commit) after `@`. Example inputs:

github.com/alice/router            -> Source=github.com/alice/router, Ref=""
github.com/alice/router@v1.2.0     -> Ref="v1.2.0"
gitlab.com/team/lib@main           -> Ref="main"

A bare `@` or empty source is rejected. Schemes (`https://`, `git@...`) are intentionally not accepted here: the source is a stable identity, and the clone URL is derived from it via CloneURL so the same package always resolves to the same lockfile key.

func ParseSpec(s string) (Spec, error)

func (s Spec) CloneURL() string

func (s Spec) DefaultName() string

func (s Spec) String() string