config

type ClientConfig struct {
	Provider string `yaml:"provider"`
	BaseURL  string `yaml:"base_url"`
	Model    string `yaml:"model"`
	APIKey   string `yaml:"api_key"`
}

type CodeIndexingConfig struct {
	// Enabled accepts true, false or "auto"; auto (the default) enables
	// source-code indexing (it is pure Go and needs no external tool). Source
	// files are split into declaration-level sections and tagged with
	// `type=code` and `language=<name>` metadata, filterable at search time.
	Enabled Toggle `yaml:"enabled"`
	// Extensions extends or overrides the built-in extension→language mapping,
	// e.g. {".phtml": "php"}. Languages: go, javascript, typescript, tsx,
	// python, php.
	Extensions map[string]string `yaml:"extensions"`
}

type Config struct {
	Version   int             `yaml:"version"`
	Store     StoreConfig     `yaml:"store"`
	Index     IndexConfig     `yaml:"index"`
	LLM       LLMConfig       `yaml:"llm"`
	Retrieval RetrievalConfig `yaml:"retrieval"`
	Converter ConverterConfig `yaml:"converter"`
	Indexing  IndexingConfig  `yaml:"indexing"`
}

type ConverterConfig struct {
	Pandoc      PandocConfig         `yaml:"pandoc"`
	LibreOffice LibreOfficeConfig    `yaml:"libreoffice"`
	GenAI       GenAIConverterConfig `yaml:"genai"`
}

type DecompositionConfig struct {
	Enabled       bool `yaml:"enabled"`
	MaxSubQueries int  `yaml:"max_sub_queries"`
}

type FulltextIndexConfig struct {
	Enabled bool    `yaml:"enabled"`
	Path    string  `yaml:"path"`
	Weight  float64 `yaml:"weight"`
}

type GenAIConverterConfig struct {
	// Enabled turns on the GenAI (OCR/LLM) converter. It is opt-in: a DSN and
	// at least one extension are required.
	Enabled bool `yaml:"enabled"`
	// DSN selects the extraction backend, e.g. mistral://?apiKey=${MISTRAL_API_KEY}
	// or marker://host:port.
	DSN string `yaml:"dsn"`
	// Extensions are routed to this converter (e.g. .pdf, .png, .jpg).
	Extensions []string `yaml:"extensions"`
}

type IndexConfig struct {
	// Driver selects the index backend. "local" (the default) uses the
	// file-based bleve full-text index and the sqlite-vec vector index,
	// configured through the fulltext/vector sections below. "postgres" uses a
	// single hybrid PostgreSQL index (native full-text + pgvector), suitable
	// for a shared deployment where several processes query the same database
	// concurrently.
	Driver   string              `yaml:"driver"`
	Fulltext FulltextIndexConfig `yaml:"fulltext"`
	Vector   VectorIndexConfig   `yaml:"vector"`
	Postgres PostgresIndexConfig `yaml:"postgres"`
}

type IndexingConfig struct {
	MaxWordsPerSection int                `yaml:"max_words_per_section"`
	TaskParallelism    int                `yaml:"task_parallelism"`
	PersistentTasks    bool               `yaml:"persistent_tasks"`
	Code               CodeIndexingConfig `yaml:"code"`
}

type IterativeConfig struct {
	Enabled   bool `yaml:"enabled"`
	MaxRounds int  `yaml:"max_rounds"`
}

type LLMCacheConfig struct {
	// Enabled accepts true, false or "auto"; auto (the default) enables the
	// cache whenever an embeddings or chat client is configured.
	Enabled Toggle `yaml:"enabled"`
	// Path is the cache root directory, relative to the .amoxtli directory
	// (default "cache"). Entries are keyed by model, so switching model never
	// serves results from the wrong space.
	Path string `yaml:"path"`
}

type LLMConfig struct {
	Chat       *ClientConfig `yaml:"chat"`
	Embeddings *ClientConfig `yaml:"embeddings"`
	// Stages assigns a dedicated chat client to individual retrieval stages
	// (hyde, judge, grounding, rerank, decompose, reformulate), overriding
	// llm.chat for that stage. The main cost lever of a search: point the
	// high-volume stages (hyde, judge) at a small fast model while keeping a
	// stronger model as the default. Requires llm.chat.
	Stages map[string]*ClientConfig `yaml:"stages"`
	// Cache is the persistent on-disk LLM cache: embedding vectors (below
	// <path>/embeddings) and deterministic seeded chat completions such as
	// HyDE (below <path>/chat).
	Cache LLMCacheConfig `yaml:"cache"`
}

type LibreOfficeConfig struct {
	// Enabled accepts true, false or "auto"; auto enables the LibreOffice
	// converter when both the libreoffice and pandoc binaries are found. It
	// supersedes the standalone pandoc converter, adding .doc support.
	Enabled Toggle `yaml:"enabled"`
}

type PandocConfig struct {
	// Enabled accepts true, false or "auto"; auto enables the pandoc
	// converter when the binary is found in the PATH.
	Enabled Toggle `yaml:"enabled"`
}

type PostgresIndexConfig struct {
	// DSN is the PostgreSQL connection string. When empty it defaults to
	// store.dsn (only valid when the store is also postgres), letting the index
	// and the document store share a single database.
	DSN    string  `yaml:"dsn"`
	Weight float64 `yaml:"weight"`
	// VectorSize is the pgvector column dimension; 0 defers to the library
	// default.
	VectorSize int `yaml:"vector_size"`
	// MaxWords bounds the chunk size sent to the embeddings model; 0 defers to
	// the library default.
	MaxWords int `yaml:"max_words"`
	// TextSearchConfig is the regconfig used when language detection is
	// inconclusive; empty defers to the library default ("simple").
	TextSearchConfig string `yaml:"text_search_config"`
}

type RetrievalConfig struct {
	// Profile selects a preset of retrieval stages: "fast" (no per-search
	// chat call), "balanced" (HyDE only) or "precision" (HyDE + grounding
	// evaluator). Empty keeps the historical default (HyDE + Judge when
	// llm.chat is configured). Explicit keys below still apply on top of the
	// profile (they can enable more stages, not disable the profile's).
	Profile           string `yaml:"profile"`
	Reranking         bool   `yaml:"reranking"`
	GroundingCheck    bool   `yaml:"grounding_check"`
	GroundingFailOpen bool   `yaml:"grounding_fail_open"`
	// MaxTotalWords bounds the prompt size (in words) of the LLM retrieval
	// stages (reranker, judge, evidence evaluator). Keep it low enough that the
	// resulting prompt fits your chat endpoint's context window: words are only
	// a coarse proxy for tokens (~1.8 tokens/word on mixed prose and code), so
	// 18000 words already overflow a 32k-token limit. Zero defers to the
	// library default (8000).
	MaxTotalWords int `yaml:"max_total_words"`
	// MaxSectionWords bounds how many words of each retrieved section are
	// included in those prompts, on top of MaxTotalWords. Relevance is almost
	// always judgeable from the beginning of a section, so a low cap cuts the
	// per-search prompt cost. Zero defers to the library default (200).
	MaxSectionWords int                 `yaml:"max_section_words"`
	Iterative       IterativeConfig     `yaml:"iterative"`
	Decomposition   DecompositionConfig `yaml:"decomposition"`
}

type StoreConfig struct {
	// Driver selects the document store backend: "sqlite" (file-based) or
	// "postgres" (client-server, for a shared/concurrent deployment).
	Driver string `yaml:"driver"`
	// DSN is the store location. For sqlite it is a path relative to the
	// .amoxtli directory; for postgres it is a connection string
	// (postgres://user:pass@host:5432/db?sslmode=disable).
	DSN string `yaml:"dsn"`
}

type Toggle string

type VectorIndexConfig struct {
	// Enabled accepts true, false or "auto"; auto enables the vector index
	// when an embeddings client is configured.
	Enabled    Toggle  `yaml:"enabled"`
	Path       string  `yaml:"path"`
	Weight     float64 `yaml:"weight"`
	VectorSize int     `yaml:"vector_size"`
	MaxWords   int     `yaml:"max_words"`
	// EmbeddingsConcurrency bounds how many embedding batches are computed in
	// parallel for a single document. It is the main lever for large-file
	// indexing latency (one big file is a single task, so cross-file parallelism
	// does not help it). Raise it if your embeddings endpoint tolerates more
	// concurrent requests; lower it to avoid rate limiting (429). 0 defers to the
	// library default.
	EmbeddingsConcurrency int `yaml:"embeddings_concurrency"`
	// ReadPool is the number of dedicated read connections opened for
	// concurrent searches (WAL). 0 defers to the library default (4).
	ReadPool int `yaml:"read_pool"`
	// CoarseQuantization enables the two-stage vector search: a fast KNN on
	// binary-quantized vectors preselects candidates, re-scored with the full
	// float vectors. Worthwhile on large corpora (100k+ chunks); requires a
	// vector size divisible by 8. Off by default.
	CoarseQuantization bool `yaml:"coarse_quantization"`
}