editorintelligence

type Detection struct {
	Found bool
	// Path is the resolved executable when found, the docker client for
	// the Docker way.
	Path string
}

type IndexState struct {
	ProfileID string `json:"id"`
	Label     string `json:"label"`
	Indexing  bool   `json:"indexing"`
	// Preparing marks the stretch before the server process answers: the
	// launcher stands up what the start needs, which for the Docker way is
	// the image build on first use. The client words that phase apart from
	// the indexing, so a first activation is never a silent minute.
	Preparing bool `json:"preparing,omitempty"`
	// Percentage is the server's reported progress, -1 while it reports
	// none, which the client shows as an indeterminate indicator.
	Percentage int `json:"percentage"`
}

type Launcher interface {
	// ID tells launchers apart in the connection slots: a server whose
	// way to run changed is evicted and restarted the way a changed root
	// evicts it. The Docker way includes its configured daemon, so a
	// moved docker-host setting evicts too.
	ID() string
	// Detect answers whether the profile's server can run this way, and
	// where the way's own executable was found.
	Detect(p *Profile) Detection
	// Prepare stands up what one start needs, bounded by ctx. The Docker
	// way builds its image on first use, creates the labeled cache volume
	// and clears the stale container's name; a way with nothing to
	// prepare returns nil. projectsRoot is the ownership boundary the
	// labels carry.
	Prepare(ctx context.Context, projectsRoot, project string, p *Profile) error
	// Argv is the command line that starts the profile's server for the
	// workspace at root. projectsRoot is the directory a container mounts
	// at its own path so file URIs match inside and outside.
	Argv(projectsRoot, project, root string, p *Profile) []string
	// ProcEnv is the extra process environment the start command needs,
	// nil for none. The Docker way carries DOCKER_HOST when the cockpit
	// is configured for a daemon of its own, so the server runs on the
	// same daemon the availability gate read.
	ProcEnv() []string
	// InitOptions are the initializationOptions this way hands the server
	// for the project, nil for none. The container way points the server's
	// index storage into its cache mount, whose per-project directory is
	// the project boundary.
	InitOptions(project string, p *Profile) any
	// SourceRoots are the directories outside the project this way lets a
	// definition land in and read back: the dependency sources the server
	// downloaded, the standard library, the server's stubs. They are the
	// whole allowlist, an answer pointing anywhere else stays counted and
	// unopened.
	SourceRoots(project string, p *Profile) []SourceRoot
	// ReadSource answers the text of one file under one of its own roots.
	// The caller has checked that the root holds the path; whether the
	// file can be read at all, and how, is this way's business.
	ReadSource(ctx context.Context, root SourceRoot, path string) (string, error)
	// WantsRestart reads a dead server's exit code: true means the way
	// asks for an immediate fresh start (the container's workspace watcher
	// ends the container with an agreed code on a relevant change), every
	// other death stays an error.
	WantsRestart(exitCode int) bool
}

type Location struct {
	Path      string `json:"path"`
	Line      int    `json:"line"`
	Character int    `json:"character"`
	External  bool   `json:"external,omitempty"`
}

type Profile struct {
	// ID is the stable profile identifier, used by the settings key.
	ID string
	// Label names the language on the settings page and in the indexing
	// indicator.
	Label string
	// Command is the server's argv, run inside the profile's container
	// over the Docker option.
	Command []string
	// Server is the short name this server wears everywhere the cockpit
	// names it itself: the image, the container, the per project cache
	// directory and the stored settings value. It is deliberately its own
	// field and not the command's leading token, which is a program name
	// and may be long enough to eat the room a container name leaves for
	// the project.
	Server string
	// Marker is the file at a project root whose presence already says
	// the project holds this language, so the warm skips the tree walk.
	Marker string
	// SilentStart marks a server that announces no work when it starts
	// because it has none: it has the workspace ready by the time it
	// answers the first request, so a lookup is never held back waiting
	// for an announcement that is not coming. The servers that index the
	// workspace at the handshake announce that run seconds late, and their
	// silence until then has to be waited out, which is the zero value
	// here: a profile that says nothing keeps the careful behaviour.
	SilentStart bool
	// contains filtered or unexported fields
}

type Request struct {
	Client      string
	ProjectName string
	ProjectRoot string
	Launcher    Launcher
	// Path is the file the cursor stands in, already validated by the
	// caller: project relative, or the absolute path of a source outside
	// the project the caller checked against the allowlist, which is what
	// a lookup from inside a read only tab asks with. Both travel the same
	// way from here, see documentPath.
	Path    string
	Content string
	// Line and Character are the 0-based LSP position, Character in UTF-16
	// units like the CodeMirror document.
	Line      int
	Character int
}

type Result struct {
	Available bool       `json:"available"`
	Status    string     `json:"status,omitempty"`
	Locations []Location `json:"locations"`
	// Outside counts targets dropped because they lie outside the project.
	Outside   int  `json:"outside,omitempty"`
	Truncated bool `json:"truncated,omitempty"`
	// Declaration reports that a definition answer covers the asked
	// position itself: the cursor already sits on the declaration, and a
	// jump would lead nowhere new.
	Declaration bool `json:"declaration,omitempty"`
}

type Service struct {
	// contains filtered or unexported fields
}

type SourceRoot struct {
	Path  string
	Image string
}

type WarmMode struct {
	ProfileID string
	Launcher  Launcher
}