dockerfile

type BuildContext interface {
	// Open opens a file for reading.
	Open(path string) (io.ReadCloser, error)
	// Stat returns file info for a path.
	Stat(path string) (os.FileInfo, error)
	// Root returns the context root path (for validation).
	Root() string
}

type BuildError struct {
	Op      string // Operation that failed (e.g., "COPY", "RUN")
	Line    int    // Line number
	Message string // Error description
	Err     error  // Underlying error
}

type BuildResult struct {
	// Ops contains the filesystem layer operations to execute.
	Ops []FSLayerOp
	// ImageRef is the base image reference from FROM.
	ImageRef string
	// RuntimeConfig contains CMD, ENTRYPOINT, USER, etc.
	RuntimeConfig RuntimeConfig
	// Env contains accumulated environment variables.
	Env []string
	// WorkDir contains the final working directory.
	WorkDir string
}

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

type Cmd interface {
	Run() error
	SetEnv(env []string) Cmd
	SetDir(dir string) Cmd
	SetUser(user string) Cmd
}

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

type Dockerfile struct {
	Stages []Stage    // Build stages (at least one)
	Args   []KeyValue // Global ARGs declared before first FROM
}

type FSLayerOp interface {
	CacheKey() string
	Apply(ctx context.Context, inst Instance) error
}

type FromInstruction struct {
	Image         string // Image reference after variable expansion
	ImageTemplate string // Original image reference before expansion (may contain $VAR)
	Tag           string // Tag portion if separated (empty if included in Image)
	Alias         string // Stage alias from "AS name"
	Platform      string // Platform from --platform flag
}

type Instance interface {
	CommandContext(ctx context.Context, name string, args ...string) Cmd
	WriteFile(name string, data []byte, perm fs.FileMode) error
	Stat(name string) (fs.FileInfo, error)
}

type Instruction struct {
	Kind     InstructionKind
	Line     int               // Source line number (1-indexed)
	Original string            // Original instruction text
	Args     []string          // Parsed arguments
	Flags    map[string]string // Flags like --from, --chown, etc.
}

type InstructionKind int

type KeyValue struct {
	Key   string
	Value string
}

type ParseError struct {
	Line    int    // Line number (1-indexed, 0 if not applicable)
	Message string // Error description
	Hint    string // Optional hint for fixing the error
}

type PathTraversalError struct {
	Path string
	Line int
}

type RuntimeConfig struct {
	Cmd         []string          // CMD instruction
	Entrypoint  []string          // ENTRYPOINT instruction
	User        string            // USER instruction
	ExposePorts []string          // EXPOSE instructions (e.g., "80/tcp")
	Labels      map[string]string // LABEL instructions
	Shell       []string          // SHELL instruction (default: ["/bin/sh", "-c"])
	StopSignal  string            // STOPSIGNAL instruction (e.g., "SIGTERM")
}

type Stage struct {
	Name         string // Stage name from "AS name" (empty if unnamed)
	From         FromInstruction
	Instructions []Instruction
}

type UnsupportedError struct {
	Feature string // Description of the unsupported feature
	Line    int    // Line number where it was encountered
}