processor

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

type CommandProcessor struct {
	*BaseProcessor
}

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

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

type MemoryProcessor struct {
	*BaseProcessor
}

type ModeProcessor struct {
	*BaseProcessor
}

type OutputConfig struct {
	Agent agent.Agent
	// RelPath is the relative path from the output directory or file where the processed content will be written
	// If the path ends with "/", it indicates a directory output
	// If it does not end with "/", it indicates a file output
	RelPath     string
	IsDirectory bool
	AgentName   string // Original agent name from config
}

type Pipeline struct {
	// Task contains the configuration for the current task being processed,
	// including its name, type, inputs, targets, and concatenation settings.
	Task config.Task

	// AbsInputRoot is the base directory path for resolving input files and determining
	// output paths. For user-scoped tasks, it represents the user's home directory.
	AbsInputRoot string

	// AbsOutputDirs is a list of output directory paths where the processed
	// content will be written. Each output directory will receive a copy of the output.
	AbsOutputDirs []string

	// UserScope indicates whether the task operates in user scope (true) or project
	// scope (false). This affects output path resolution and file organization.
	UserScope bool

	// DryRun indicates whether the pipeline should actually write files to disk.
	// When true, the pipeline will simulate file operations but not actually write files.
	DryRun bool

	// Force indicates whether to overwrite files without confirmation.
	// When true, existing files will be overwritten without prompting.
	Force bool
	// contains filtered or unexported fields
}

type ProcessedFile struct {

	// Content is the processed file content
	Content string
	// AgentName is the name of the agent for this file
	AgentName string
	// contains filtered or unexported fields
}

type ProcessorStrategy[T any] interface {
	Parse(absPath string, raw []byte) (T, error)
	GetContent(item T) string
	SetContent(item T, content string) T
	FormatOne(a agent.Agent, item T) (string, error)
	FormatMany(a agent.Agent, items []T) (string, error)
}

type TaskProcessor interface {
	// Process handles task-specific processing of inputs and returns the processed result
	Process(inputs []string, cfg *OutputConfig) (*TaskResult, error)

	// GetOutputPath returns the appropriate output path for the given agent and task type
	GetOutputPath(agent agent.Agent, outputPath string) string
}

type TaskResult struct {
	Files []ProcessedFile
}