wehub-resource-sync
a06f331eb8
CI / benchmark (push) Has been skipped
install-script / posix-syntax (push) Successful in 6m1s
CI / build-onnx (push) Failing after 6m43s
init-smoke / dry-run (push) Failing after 15m57s
security / govulncheck (push) Has been cancelled
security / trivy-fs (push) Has been cancelled
CI / test (1.26, ubuntu-latest) (push) Has been cancelled
Scorecard supply-chain security / Scorecard analysis (push) Has been cancelled
CI / test (1.26, macos-latest) (push) Has been cancelled
CI / build-windows (push) Has been cancelled
CI / lint (push) Has been cancelled
install-script / powershell-syntax (push) Has been cancelled
install-script / install (macos-14) (push) Has been cancelled
install-script / install (ubuntu-latest) (push) Has been cancelled
1896 lines
93 KiB
Go
1896 lines
93 KiB
Go
package config
|
||
|
||
import (
|
||
"fmt"
|
||
"os"
|
||
"runtime"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/spf13/viper"
|
||
|
||
"github.com/zzet/gortex/internal/llm"
|
||
"github.com/zzet/gortex/internal/platform"
|
||
)
|
||
|
||
type GuardRule struct {
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
Kind string `mapstructure:"kind" yaml:"kind"` // "co-change" | "boundary"
|
||
Source string `mapstructure:"source" yaml:"source"` // package/path prefix
|
||
Target string `mapstructure:"target" yaml:"target"` // package/path prefix
|
||
Message string `mapstructure:"message" yaml:"message,omitempty"` // human-readable explanation
|
||
// Severity tiers the violation: "error" → a change_contract refuse,
|
||
// "warn" → warn, "info" → annotate. Empty defaults to "warn" so a rule
|
||
// advises until it explicitly opts into blocking.
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
// Except lists path globs exempt from this rule — a source symbol whose
|
||
// file matches one is never flagged.
|
||
Except []string `mapstructure:"except" yaml:"except,omitempty"`
|
||
}
|
||
|
||
type GuardsConfig struct {
|
||
Rules []GuardRule `mapstructure:"rules" yaml:"rules,omitempty"`
|
||
}
|
||
|
||
// EventRule is one declarative event-boundary / dispatch-guard constraint over
|
||
// the pub/sub graph: which paths may produce or consume a topic, whether a
|
||
// produced topic must have a consumer, and which paths are forbidden from it.
|
||
type EventRule struct {
|
||
Name string `mapstructure:"name" yaml:"name,omitempty"`
|
||
Topic string `mapstructure:"topic" yaml:"topic,omitempty"` // glob on event/topic name; empty = any
|
||
Producer string `mapstructure:"producer" yaml:"producer,omitempty"` // path glob allowed to produce
|
||
Consumer string `mapstructure:"consumer" yaml:"consumer,omitempty"` // path glob allowed to consume
|
||
RequireConsumer bool `mapstructure:"require_consumer" yaml:"require_consumer,omitempty"` // a produced topic must have a consumer
|
||
Forbid []string `mapstructure:"forbid" yaml:"forbid,omitempty"` // path globs forbidden to produce / consume
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
Message string `mapstructure:"message" yaml:"message,omitempty"`
|
||
}
|
||
|
||
// EventsConfig is the `events:` block of .gortex.yaml — declarative
|
||
// event-boundary rules over the pub/sub graph (EdgeEmits / EdgeProducesTopic /
|
||
// EdgeListensOn / EdgeConsumesTopic), evaluated as a change_contract rule
|
||
// family.
|
||
type EventsConfig struct {
|
||
Rules []EventRule `mapstructure:"rules" yaml:"rules,omitempty"`
|
||
}
|
||
|
||
// ArchitectureConfig is the declarative architecture-rules block of
|
||
// .gortex.yaml — the top-level `architecture:` key. It promotes the
|
||
// flat guards: list into named layers with directional allow/deny
|
||
// dependency constraints; check_guards evaluates it on every change
|
||
// set. The flat guards: list keeps working unchanged alongside it.
|
||
type ArchitectureConfig struct {
|
||
// Layers maps a layer name to its definition. A file belongs to
|
||
// the layer whose Paths globs match it — or, when a layer
|
||
// declares no Paths, whose name appears as a path segment.
|
||
Layers map[string]LayerRule `mapstructure:"layers" yaml:"layers,omitempty"`
|
||
// Rules are per-layer / per-pattern dependency-cone constraints —
|
||
// fan-out caps and caller-boundary restrictions — evaluated on
|
||
// top of the layer allow/deny graph.
|
||
Rules []ArchRule `mapstructure:"rules" yaml:"rules,omitempty"`
|
||
// Severity tiers the layer allow/deny violations: "error" → a
|
||
// change_contract refuse, "warn" → warn, "info" → annotate. Empty
|
||
// defaults to "warn".
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
}
|
||
|
||
// ArchRule is one architecture constraint scoped to a layer or a file
|
||
// glob: a dependency-cone fan-out limit, a caller-boundary
|
||
// restriction, or both.
|
||
type ArchRule struct {
|
||
// Name is an optional human label surfaced on violations.
|
||
Name string `mapstructure:"name" yaml:"name,omitempty"`
|
||
// Layer scopes the rule to symbols in this architecture layer.
|
||
Layer string `mapstructure:"layer" yaml:"layer,omitempty"`
|
||
// Pattern scopes the rule to symbols whose file matches this glob.
|
||
// When both Layer and Pattern are set a symbol must match both.
|
||
Pattern string `mapstructure:"pattern" yaml:"pattern,omitempty"`
|
||
// MaxFanOut caps the number of distinct symbols a scoped symbol
|
||
// may call or reference. 0 disables the fan-out check.
|
||
MaxFanOut int `mapstructure:"max_fan_out" yaml:"max_fan_out,omitempty"`
|
||
// DenyCallersOutside restricts who may call into the scoped set:
|
||
// every caller's file must match one of these globs. The scoped
|
||
// set is always allowed to call within itself.
|
||
DenyCallersOutside []string `mapstructure:"deny_callers_outside" yaml:"deny_callers_outside,omitempty"`
|
||
// Message is an optional human-readable explanation.
|
||
Message string `mapstructure:"message" yaml:"message,omitempty"`
|
||
// Severity tiers the violation: "error" → a change_contract refuse,
|
||
// "warn" → warn, "info" → annotate. Empty defaults to "warn".
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
// Except lists path globs exempt from this rule.
|
||
Except []string `mapstructure:"except" yaml:"except,omitempty"`
|
||
}
|
||
|
||
// ArtifactEntry is one row of the `artifacts:` manifest — a non-code
|
||
// knowledge file (DB schema, API spec, infra config, ADR) tracked as
|
||
// a first-class KindArtifact graph node.
|
||
type ArtifactEntry struct {
|
||
// Path is a file path or glob, repo-relative. ** matches any
|
||
// number of directory segments.
|
||
Path string `mapstructure:"path" yaml:"path"`
|
||
// Kind is schema | api | infra | doc. Auto-detected from the file
|
||
// extension when empty.
|
||
Kind string `mapstructure:"kind" yaml:"kind,omitempty"`
|
||
// Name is an optional display name; defaults to the file's base
|
||
// name.
|
||
Name string `mapstructure:"name" yaml:"name,omitempty"`
|
||
}
|
||
|
||
// NamedQuery is one row of the `queries:` block — a named, reusable
|
||
// bundle of structural detectors. Running it (`analyze kind=named
|
||
// name=<name>`) fans every selected detector across the codebase and
|
||
// aggregates the matches. A detector joins the bundle when it carries
|
||
// one of the Tags or its name is listed in Detectors.
|
||
type NamedQuery struct {
|
||
// Name is the bundle identifier passed to `analyze kind=named`.
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
// Description is a human-readable summary of the bundle's intent.
|
||
Description string `mapstructure:"description" yaml:"description,omitempty"`
|
||
// Tags selects every detector carrying any of these tags
|
||
// (e.g. injection, secrets, crypto).
|
||
Tags []string `mapstructure:"tags" yaml:"tags,omitempty"`
|
||
// Detectors selects detectors by exact name — for pulling in a
|
||
// specific rule (including a user rule from rule_files).
|
||
Detectors []string `mapstructure:"detectors" yaml:"detectors,omitempty"`
|
||
// Severity is an optional minimum severity floor — info | warning
|
||
// | error. Detectors below it are dropped from the bundle.
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
}
|
||
|
||
// LayerRule defines one architecture layer: the files that belong to
|
||
// it and the layers it may or may not depend on.
|
||
type LayerRule struct {
|
||
// Paths are globs (with ** matching any number of path segments)
|
||
// selecting the files that belong to this layer. When empty the
|
||
// layer matches files whose path carries the layer name as a
|
||
// segment — so a terse `domain: {allow: [...]}` still works.
|
||
Paths []string `mapstructure:"paths" yaml:"paths,omitempty"`
|
||
// Allow whitelists the layers this layer may depend on; "*"
|
||
// permits any. A non-empty Allow makes every unlisted layer a
|
||
// violation.
|
||
Allow []string `mapstructure:"allow" yaml:"allow,omitempty"`
|
||
// Deny blacklists layers this layer must not depend on; "*"
|
||
// denies every cross-layer dependency not rescued by Allow.
|
||
Deny []string `mapstructure:"deny" yaml:"deny,omitempty"`
|
||
}
|
||
|
||
// IsEmpty reports whether no architecture rules are configured — the
|
||
// signal for check_guards to skip the layered evaluation entirely.
|
||
func (a ArchitectureConfig) IsEmpty() bool {
|
||
return len(a.Layers) == 0 && len(a.Rules) == 0
|
||
}
|
||
|
||
// MultiRepoConfig holds workspace-discovery settings used by the
|
||
// multi-repo bootstrapper. Carries the (formerly `workspace.auto_detect`)
|
||
// flag — moved out from under `workspace:` because that key is now
|
||
// reclaimed for the workspace-identity slug.
|
||
type MultiRepoConfig struct {
|
||
// AutoDetect — when true, tracking a parent directory walks its
|
||
// immediate subdirectories looking for `.git/`, treating each
|
||
// match as a tracked repo. The legacy YAML key
|
||
// `workspace.auto_detect: true` is still accepted by the custom
|
||
// Config unmarshaller for one release; the canonical key going
|
||
// forward is `multi.auto_detect`.
|
||
AutoDetect bool `mapstructure:"auto_detect" yaml:"auto_detect,omitempty"`
|
||
}
|
||
|
||
// ProjectGlob declares a project's path-globs inside a monorepo.
|
||
//
|
||
// projects:
|
||
// - name: api
|
||
// paths: ["services/api/**"]
|
||
// - name: worker
|
||
// paths: ["services/worker/**"]
|
||
//
|
||
// A file is assigned to the first project whose globs match (longest
|
||
// glob wins on overlap). Files matching no glob get the workspace-
|
||
// default project name with a warning at index time.
|
||
type ProjectGlob struct {
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
Paths []string `mapstructure:"paths" yaml:"paths"`
|
||
}
|
||
|
||
// CrossWorkspaceDep declares an explicit, opt-in dependency from this
|
||
// workspace into another.
|
||
//
|
||
// cross_workspace_deps:
|
||
// - workspace: gortex
|
||
// modules: [github.com/gortexhq/gortex]
|
||
// mode: read-only
|
||
//
|
||
// `Mode` must be `read-only` in iteration 1 — any other value is
|
||
// rejected at config-load time with a clear error.
|
||
type CrossWorkspaceDep struct {
|
||
Workspace string `mapstructure:"workspace" yaml:"workspace"`
|
||
Modules []string `mapstructure:"modules" yaml:"modules"`
|
||
Mode string `mapstructure:"mode" yaml:"mode"`
|
||
}
|
||
|
||
// SemanticConfig holds settings for the semantic enrichment layer.
|
||
type SemanticConfig struct {
|
||
Enabled bool `mapstructure:"enabled" yaml:"enabled"`
|
||
TimeoutSeconds int `mapstructure:"timeout_seconds" yaml:"timeout_seconds,omitempty"`
|
||
EnrichOnWatch bool `mapstructure:"enrich_on_watch" yaml:"enrich_on_watch,omitempty"`
|
||
WatchDebounceMs int `mapstructure:"watch_debounce_ms" yaml:"watch_debounce_ms,omitempty"`
|
||
RefuteUnconfirmed bool `mapstructure:"refute_unconfirmed" yaml:"refute_unconfirmed,omitempty"`
|
||
Providers []SemanticProviderConfig `mapstructure:"providers" yaml:"providers,omitempty"`
|
||
// GoTypes enables the heavyweight go/packages type-check provider
|
||
// ("go-types"): a full `go list ./...` + go/types pass over the module
|
||
// (and its dependencies) on every index. The in-process tree-sitter Go
|
||
// resolver (go-ast-types) is the always-on floor and resolves the common
|
||
// receiver / cross-file call cases with no toolchain; the go/packages
|
||
// provider adds full cross-package / generic type precision but costs
|
||
// tens of seconds per Go module per warmup and, on an already-resolved
|
||
// graph, frequently confirms zero new edges. Tri-state, DEFAULT OFF —
|
||
// opt in for maximum Go type precision. Env override GORTEX_GO_TYPES=1/0.
|
||
GoTypes *bool `mapstructure:"go_types" yaml:"go_types,omitempty"`
|
||
// AdditionalWorkspaceFolders are extra directory roots passed to
|
||
// every LSP server's `initialize` request as workspace folders.
|
||
// This is how cross-package resolution works for a TypeScript (or
|
||
// any) project that imports from a sibling package living outside
|
||
// the indexed repo root — the language server is told to treat
|
||
// those folders as part of the same workspace.
|
||
AdditionalWorkspaceFolders []string `mapstructure:"additional_workspace_folders" yaml:"additional_workspace_folders,omitempty"`
|
||
// ExcludeGlobs lists path globs to skip for semantic enrichment, in
|
||
// addition to the built-in generated/vendored heuristic (vendored deps,
|
||
// tree-sitter generated parser.c, protobuf-generated files, …). A file
|
||
// matching any glob is not enriched and does not count toward a repo's
|
||
// present languages, so a language server is not spawned just to index it.
|
||
ExcludeGlobs []string `mapstructure:"exclude_globs" yaml:"exclude_globs,omitempty"`
|
||
// LSPSweep selects how much of the per-file LSP hover / call-hierarchy
|
||
// enrichment sweep runs. On an already-resolved graph that sweep re-opens
|
||
// and re-hovers every file to confirm zero new edges, so gating it cuts
|
||
// warm-restart churn:
|
||
// - "demand" (DEFAULT / empty): sweep only files whose declarations
|
||
// still carry unresolved same-name call candidates.
|
||
// - "full": sweep every file of the language (pre-knob behaviour).
|
||
// - "off": skip the per-file sweep; the tier-deciding confirm / add
|
||
// passes still run.
|
||
// The GORTEX_LSP_SWEEP env override wins over this setting.
|
||
LSPSweep string `mapstructure:"lsp_sweep" yaml:"lsp_sweep,omitempty"`
|
||
// EagerLSP runs the subprocess LSP servers during synchronous enrichment.
|
||
// Default false: LSP is the slowest part of a cold index and the in-process
|
||
// tiers (go-types, tree-sitter floor) cover the fast baseline, so LSP is
|
||
// lazy-spawned on demand instead. GORTEX_LSP_EAGER=1 restores eager LSP.
|
||
EagerLSP bool `mapstructure:"eager_lsp" yaml:"eager_lsp,omitempty"`
|
||
// SkipEmbed lists (language, kind) combinations that should be
|
||
// indexed for graph queries but *not* embedded into the vector
|
||
// search. Design tokens (CSS custom properties), terraform
|
||
// resource blocks, YAML/TOML/shell config variables are usually
|
||
// searched by literal name, so paying the embedding + HNSW cost
|
||
// buys nothing. See excludes.DefaultSkipEmbed for the baseline.
|
||
SkipEmbed []SkipEmbedRule `mapstructure:"skip_embed" yaml:"skip_embed,omitempty"`
|
||
|
||
// SkipSearch lists (language, kind) combinations that should be
|
||
// kept in the graph but excluded from the text search index
|
||
// (BM25/Bleve). Same shape as SkipEmbed but targets a different
|
||
// index. The motivating case: a big monorepo with ~135k JSON
|
||
// `variable` nodes (package.json keys, tsconfig entries, etc.)
|
||
// pushed total symbol count over search.AutoThreshold and
|
||
// triggered an auto-upgrade from BM25 (~900 B/doc) to Bleve
|
||
// (~32 KiB/doc). Those config-key nodes aren't useful search
|
||
// targets — users who want to find them by name still can via
|
||
// graph queries. Defaults are a superset of SkipEmbed because
|
||
// anything that isn't worth embedding usually isn't worth
|
||
// full-text-indexing either. See DefaultSkipSearch.
|
||
SkipSearch []SkipEmbedRule `mapstructure:"skip_search" yaml:"skip_search,omitempty"`
|
||
}
|
||
|
||
// GoTypesEnabledOrDefault resolves the tri-state SemanticConfig.GoTypes.
|
||
// The heavyweight go/packages type-check provider is OFF by default — the
|
||
// always-on tree-sitter Go floor (go-ast-types) serves Go resolution — so
|
||
// opt in explicitly for full cross-package type precision.
|
||
func (s SemanticConfig) GoTypesEnabledOrDefault() bool {
|
||
if s.GoTypes == nil {
|
||
return false
|
||
}
|
||
return *s.GoTypes
|
||
}
|
||
|
||
// SkipEmbedRule says: when a node's Language matches Language AND its
|
||
// Kind is in Kinds, skip it during vector-index construction.
|
||
type SkipEmbedRule struct {
|
||
Language string `mapstructure:"language" yaml:"language"`
|
||
Kinds []string `mapstructure:"kinds" yaml:"kinds"`
|
||
}
|
||
|
||
// ShouldSkipEmbed reports whether a node of the given (language, kind)
|
||
// falls under any rule in the list. Matching is case-sensitive and
|
||
// exact — parser output is canonical already.
|
||
func ShouldSkipEmbed(rules []SkipEmbedRule, language, kind string) bool {
|
||
return matchesSkipRule(rules, language, kind)
|
||
}
|
||
|
||
// ShouldSkipSearch reports whether a node of the given (language, kind)
|
||
// falls under any text-index skip rule. Same matching semantics as
|
||
// ShouldSkipEmbed — kept as a distinct function so callers make the
|
||
// embed/search distinction explicit, and so the two defaults can
|
||
// diverge over time.
|
||
func ShouldSkipSearch(rules []SkipEmbedRule, language, kind string) bool {
|
||
return matchesSkipRule(rules, language, kind)
|
||
}
|
||
|
||
// matchesSkipRule is the shared (language, kind) matcher for SkipEmbed
|
||
// and SkipSearch. Case-sensitive and exact; parser output is canonical.
|
||
func matchesSkipRule(rules []SkipEmbedRule, language, kind string) bool {
|
||
for _, r := range rules {
|
||
if r.Language == language && slices.Contains(r.Kinds, kind) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// DefaultSkipEmbed returns the compiled-in baseline for which node
|
||
// kinds skip embedding. Kept as a function (rather than a var) so
|
||
// callers who mutate the returned slice don't affect each other.
|
||
func DefaultSkipEmbed() []SkipEmbedRule {
|
||
return []SkipEmbedRule{
|
||
// Design tokens — searched by literal name, not concept.
|
||
{Language: "css", Kinds: []string{"variable", "type"}},
|
||
// Terraform resource/locals/variable blocks — searched
|
||
// literally (aws_vpc.main, module.foo).
|
||
{Language: "hcl", Kinds: []string{"type", "variable"}},
|
||
// Config keys — usually not meaningful prose.
|
||
{Language: "yaml", Kinds: []string{"variable"}},
|
||
{Language: "toml", Kinds: []string{"variable"}},
|
||
// Shell variables are nearly always noise for semantic search.
|
||
{Language: "bash", Kinds: []string{"variable"}},
|
||
}
|
||
}
|
||
|
||
// DefaultSkipSearch returns the baseline (language, kind) pairs that
|
||
// are kept out of the text search index. Superset of DefaultSkipEmbed:
|
||
// if a node isn't worth a vector slot it generally isn't worth a BM25/
|
||
// Bleve slot either, and on big monorepos these config-key nodes are
|
||
// what pushes the backend into its Bleve auto-upgrade (~32 KiB/doc).
|
||
// JSON is the heaviest of the additions — tsconfig / package.json /
|
||
// lockfile keys alone can account for >100k variable nodes.
|
||
func DefaultSkipSearch() []SkipEmbedRule {
|
||
rules := DefaultSkipEmbed()
|
||
rules = append(rules,
|
||
// Object keys — searched by exact path, not full-text.
|
||
SkipEmbedRule{Language: "json", Kinds: []string{"variable"}},
|
||
// Template/markup variables — too noisy to index by name.
|
||
SkipEmbedRule{Language: "liquid", Kinds: []string{"variable"}},
|
||
SkipEmbedRule{Language: "jinja", Kinds: []string{"variable"}},
|
||
// Markdown code-block `variable` nodes (one per fenced block)
|
||
// are noise -- searched by literal name, never by concept. The
|
||
// rule is scoped to `variable` ONLY: the first-class KindDoc
|
||
// prose-section nodes (kind "doc") are deliberately left IN the
|
||
// search index so a prose query ranks the right section.
|
||
SkipEmbedRule{Language: "markdown", Kinds: []string{"variable"}},
|
||
// Build-system variables (Makefile/Dockerfile ARG/ENV) are
|
||
// typically searched by literal name, not concept.
|
||
SkipEmbedRule{Language: "makefile", Kinds: []string{"variable"}},
|
||
SkipEmbedRule{Language: "dockerfile", Kinds: []string{"variable"}},
|
||
)
|
||
return rules
|
||
}
|
||
|
||
// SemanticProviderConfig configures a single semantic provider.
|
||
type SemanticProviderConfig struct {
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
Command string `mapstructure:"command" yaml:"command,omitempty"`
|
||
Args []string `mapstructure:"args" yaml:"args,omitempty"`
|
||
Languages []string `mapstructure:"languages" yaml:"languages"`
|
||
Priority int `mapstructure:"priority" yaml:"priority,omitempty"`
|
||
Enabled bool `mapstructure:"enabled" yaml:"enabled"`
|
||
Mode string `mapstructure:"mode" yaml:"mode,omitempty"`
|
||
Daemon bool `mapstructure:"daemon" yaml:"daemon,omitempty"`
|
||
MaxParallel int `mapstructure:"max_parallel" yaml:"max_parallel,omitempty"`
|
||
// Env adds KEY=VALUE environment entries to the provider's
|
||
// subprocess. The motivating case is pinning a JRE for the
|
||
// heavyweight jdtls Java server (env: ["JAVA_HOME=/path/to/jdk"]),
|
||
// but it works for any LSP server that needs a tuned environment.
|
||
// Command / Args / Env set here override the built-in spec.
|
||
Env []string `mapstructure:"env" yaml:"env,omitempty"`
|
||
// Connect, when non-nil, switches this provider from spawning its
|
||
// own LSP subprocess to dialing an already-running endpoint —
|
||
// typically the LSP server the user's IDE is already managing.
|
||
// When set, validation requires non-empty network + address; an
|
||
// empty block is rejected with a clear error.
|
||
Connect *SemanticConnectConfig `mapstructure:"connect" yaml:"connect,omitempty"`
|
||
}
|
||
|
||
// SemanticConnectConfig is the YAML-bound passive-attach block under
|
||
// `semantic.providers[*].connect`. Carrier is tcp or unix; address is
|
||
// host:port (tcp) or socket path (unix). When fallback_spawn is true,
|
||
// a failed dial falls back to spawning the configured subprocess.
|
||
type SemanticConnectConfig struct {
|
||
Network string `mapstructure:"network" yaml:"network"`
|
||
Address string `mapstructure:"address" yaml:"address"`
|
||
FallbackSpawn bool `mapstructure:"fallback_spawn" yaml:"fallback_spawn,omitempty"`
|
||
}
|
||
|
||
// Validate reports a clear error for a malformed Connect block — both
|
||
// fields empty, or an unsupported network. Returns nil for a nil
|
||
// receiver (spawn-mode is fine), and nil for a well-formed block.
|
||
func (c *SemanticConnectConfig) Validate() error {
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
if strings.TrimSpace(c.Network) == "" && strings.TrimSpace(c.Address) == "" {
|
||
return fmt.Errorf("semantic.providers.connect: network and address are required")
|
||
}
|
||
if strings.TrimSpace(c.Network) == "" {
|
||
return fmt.Errorf("semantic.providers.connect: network is required (tcp or unix)")
|
||
}
|
||
if strings.TrimSpace(c.Address) == "" {
|
||
return fmt.Errorf("semantic.providers.connect: address is required")
|
||
}
|
||
switch strings.ToLower(strings.TrimSpace(c.Network)) {
|
||
case "tcp", "tcp4", "tcp6", "unix":
|
||
default:
|
||
return fmt.Errorf("semantic.providers.connect: unsupported network %q (want tcp or unix)", c.Network)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type Config struct {
|
||
// Exclude is the unified ignore list (gitignore semantics) used by
|
||
// both indexing and watching. Workspace-level patterns are appended
|
||
// to builtin + global + per-RepoEntry layers; use `!pattern` to
|
||
// re-include something an outer layer excluded.
|
||
Exclude []string `mapstructure:"exclude" yaml:"exclude,omitempty"`
|
||
|
||
// Include force-indexes paths an outer layer (notably the repo
|
||
// .gitignore) excludes — the dedicated, readable counterpart to
|
||
// hand-writing `!pattern` negations in Exclude. Each entry is appended
|
||
// last as a gitignore `!pattern` re-include, so it wins over the
|
||
// builtin / .gitignore / global / repo exclude layers. Use it for a
|
||
// vendored or generated tree you nonetheless want in the graph
|
||
// (e.g. Pods/, a per-customer customer/ directory).
|
||
Include []string `mapstructure:"include" yaml:"include,omitempty"`
|
||
|
||
// RuleFiles are paths (or globs) to TOML files of user-defined
|
||
// domain-extractor rules. Each rule is a tree-sitter pattern that
|
||
// becomes a registered detector surfaced through `analyze
|
||
// kind=domain` — the pluggable way to extract HTTP routes, CLI
|
||
// commands, feature flags, i18n keys, event-bus topics, etc.
|
||
RuleFiles []string `mapstructure:"rule_files" yaml:"rule_files,omitempty"`
|
||
|
||
// RespectGitignore controls whether the repo's `.gitignore` file is
|
||
// read and its patterns added to the effective exclude list. Default
|
||
// is true (respect .gitignore); set `respect_gitignore: false` in
|
||
// `.gortex.yaml` to opt out for repos that rely on indexing
|
||
// otherwise-ignored generated code or vendored sources. Pointer so
|
||
// the loader can distinguish "explicitly false" from "absent".
|
||
RespectGitignore *bool `mapstructure:"respect_gitignore" yaml:"respect_gitignore,omitempty"`
|
||
|
||
// Workspace is the hard-boundary slug this repo belongs to.
|
||
// Top-level `workspace: <slug>` in `.gortex.yaml`. Empty → defaults
|
||
// to the repo name (resolved by the indexer; see
|
||
// resolveWorkspaceID). Two repos with different non-empty slugs
|
||
// have their contract surfaces and queries strictly isolated.
|
||
Workspace string `mapstructure:"workspace" yaml:"workspace,omitempty"`
|
||
|
||
// Project is the soft sub-boundary slug for single-project repos.
|
||
// Top-level `project: <slug>`. When `Projects[]` is set
|
||
// (monorepo case) this scalar field is ignored — file-to-project
|
||
// mapping comes from the glob list instead.
|
||
Project string `mapstructure:"project" yaml:"project,omitempty"`
|
||
|
||
// Projects is the monorepo per-file project mapping. Top-level
|
||
// `projects: [{name, paths: [globs]}]`. Mutually exclusive with
|
||
// `Project` for clarity; when both are set the loader rejects
|
||
// the config.
|
||
Projects []ProjectGlob `mapstructure:"projects" yaml:"projects,omitempty"`
|
||
|
||
// CrossWorkspaceDeps declares opt-in dependencies into other
|
||
// workspaces. Only `mode: read-only` is accepted in iteration 1.
|
||
CrossWorkspaceDeps []CrossWorkspaceDep `mapstructure:"cross_workspace_deps" yaml:"cross_workspace_deps,omitempty"`
|
||
|
||
Index IndexConfig `mapstructure:"index" yaml:"index,omitempty"`
|
||
Watch WatchConfig `mapstructure:"watch" yaml:"watch,omitempty"`
|
||
Query QueryConfig `mapstructure:"query" yaml:"query,omitempty"`
|
||
Scope ScopeConfig `mapstructure:"scope" yaml:"scope,omitempty"`
|
||
Search SearchConfig `mapstructure:"search" yaml:"search,omitempty"`
|
||
// Embedding configures the semantic-search vector channel: the
|
||
// embedding provider plus the chunking / concurrency knobs the
|
||
// indexer uses to build the vector index. The vector channel is
|
||
// on by default with the zero-download static GloVe provider.
|
||
Embedding EmbeddingConfig `mapstructure:"embedding" yaml:"embedding,omitempty"`
|
||
MCP MCPConfig `mapstructure:"mcp" yaml:"mcp,omitempty"`
|
||
Guards GuardsConfig `mapstructure:"guards" yaml:"guards,omitempty"`
|
||
// Federation tunes the read-only cross-daemon fan-out:
|
||
// per-remote deadline, global budget, circuit breaker, and the
|
||
// opt-in name-keyed fallback. Zero values fall back to defaults.
|
||
Federation FederationConfig `mapstructure:"federation" yaml:"federation,omitempty"`
|
||
// Architecture is the declarative layer / allow-deny DSL. Empty
|
||
// by default; the flat Guards list above keeps working when it is
|
||
// unset.
|
||
Architecture ArchitectureConfig `mapstructure:"architecture" yaml:"architecture,omitempty"`
|
||
// Events is the declarative event-boundary rule family — pub/sub
|
||
// producer/consumer path constraints, evaluated by change_contract.
|
||
Events EventsConfig `mapstructure:"events" yaml:"events,omitempty"`
|
||
// Artifacts is the non-code knowledge manifest — schemas, API
|
||
// specs, infra configs, and ADRs surfaced as KindArtifact nodes.
|
||
Artifacts []ArtifactEntry `mapstructure:"artifacts" yaml:"artifacts,omitempty"`
|
||
// Queries are named, reusable detector bundles runnable via
|
||
// `analyze kind=named`.
|
||
Queries []NamedQuery `mapstructure:"queries" yaml:"queries,omitempty"`
|
||
Multi MultiRepoConfig `mapstructure:"multi" yaml:"multi,omitempty"`
|
||
Semantic SemanticConfig `mapstructure:"semantic" yaml:"semantic,omitempty"`
|
||
// LLM configures the LLM service that backs the `ask` MCP tool and
|
||
// the search-assist passes. Empty by default — daemon skips LLM
|
||
// wiring entirely when the active provider has no model configured.
|
||
// The `llm.provider` key selects the backend (local / anthropic /
|
||
// openai / ollama / claudecli); env vars GORTEX_LLM_* override file
|
||
// values; see internal/llm/config.go::Config.MergeEnv.
|
||
LLM llm.Config `mapstructure:"llm" yaml:"llm,omitempty"`
|
||
// Review tunes the PR-review surface: the layered path-glob rule
|
||
// list, the gating thresholds applied to surfaced findings, the
|
||
// depth-selection bounds, and the posting gate. Empty by default;
|
||
// the embedded default rules apply when no rule is configured.
|
||
Review ReviewConfig `mapstructure:"review" yaml:"review,omitempty"`
|
||
}
|
||
|
||
// ReviewConfig is the `review:` block. It carries every knob the
|
||
// PR-review layers read: the path-glob rule list (resolved by
|
||
// review.RuleResolver), the gating thresholds applied to surfaced
|
||
// findings, the depth-selection bounds, and the comment-posting gate.
|
||
// The whole struct lands here so later layers only read these fields.
|
||
type ReviewConfig struct {
|
||
// Rules is the ordered path-glob rule list. The first rule whose
|
||
// glob matches a changed file selects its severity floor and
|
||
// rulepack; an empty list falls through to the embedded defaults.
|
||
Rules []ReviewRule `mapstructure:"rules" yaml:"rules,omitempty"`
|
||
// MinConfidence drops any finding scored below this confidence
|
||
// (0..1). Zero keeps every finding.
|
||
MinConfidence float64 `mapstructure:"min_confidence" yaml:"min_confidence,omitempty"`
|
||
// MinSeverity is the minimum severity floor — info | warning |
|
||
// error | critical. Findings below it are dropped. Empty keeps all.
|
||
MinSeverity string `mapstructure:"min_severity" yaml:"min_severity,omitempty"`
|
||
// Categories, when set, restricts surfaced findings to these
|
||
// categories. Empty keeps every category.
|
||
Categories []string `mapstructure:"categories" yaml:"categories,omitempty"`
|
||
// MaxFindings caps how many findings are surfaced. Zero is no cap.
|
||
MaxFindings int `mapstructure:"max_findings" yaml:"max_findings,omitempty"`
|
||
// QuickMaxLines is the changed-line ceiling under which a review
|
||
// runs in the quick (shallow) mode. Zero uses the built-in default.
|
||
QuickMaxLines int `mapstructure:"quick_max_lines" yaml:"quick_max_lines,omitempty"`
|
||
// DeepMinLines is the changed-line floor at or above which a review
|
||
// escalates to the deep mode. Zero uses the built-in default.
|
||
DeepMinLines int `mapstructure:"deep_min_lines" yaml:"deep_min_lines,omitempty"`
|
||
// DeepMinFiles is the changed-file floor at or above which a review
|
||
// escalates to the deep mode. Zero uses the built-in default.
|
||
DeepMinFiles int `mapstructure:"deep_min_files" yaml:"deep_min_files,omitempty"`
|
||
// Post gates comment posting.
|
||
Post ReviewPostConfig `mapstructure:"post" yaml:"post,omitempty"`
|
||
}
|
||
|
||
// ReviewPostConfig gates how review findings are posted back. Posting
|
||
// to a public or forked repository is opt-in.
|
||
type ReviewPostConfig struct {
|
||
// AllowPublic permits posting comments on public / fork repos.
|
||
// Off by default so a misconfigured token never leaks comments.
|
||
AllowPublic bool `mapstructure:"allow_public" yaml:"allow_public,omitempty"`
|
||
}
|
||
|
||
// ReviewRule is one path-glob review rule. Path is a gitignore-style
|
||
// glob (so `**` works); the first rule whose Path matches a changed
|
||
// file selects its Severity floor and Rulepack. A Disabled rule is
|
||
// skipped during resolution.
|
||
type ReviewRule struct {
|
||
// Name is the human-readable rule identifier.
|
||
Name string `mapstructure:"name" yaml:"name,omitempty"`
|
||
// Path is the gitignore-style glob the changed file is matched
|
||
// against (e.g. `**/*_test.go`, `internal/auth/**`, `**`).
|
||
Path string `mapstructure:"path" yaml:"path,omitempty"`
|
||
// Severity is an optional severity floor for findings grounded to
|
||
// a file this rule selects — info | warning | error | critical.
|
||
Severity string `mapstructure:"severity" yaml:"severity,omitempty"`
|
||
// Rulepack names the detector bundle to run for a matched file.
|
||
Rulepack string `mapstructure:"rulepack" yaml:"rulepack,omitempty"`
|
||
// Disabled skips this rule entirely during resolution.
|
||
Disabled bool `mapstructure:"disabled" yaml:"disabled,omitempty"`
|
||
}
|
||
|
||
type IndexConfig struct {
|
||
Languages []string `mapstructure:"languages" yaml:"languages,omitempty"`
|
||
// Exclude is deprecated — use top-level Config.Exclude instead.
|
||
// Still read for one release so existing .gortex.yaml files don't
|
||
// silently stop working; merged into the unified list by ConfigManager.
|
||
Exclude []string `mapstructure:"exclude" yaml:"exclude,omitempty"`
|
||
Workers int `mapstructure:"workers" yaml:"workers,omitempty"`
|
||
// SkipEmbed is the effective skip-embedding rules resolved from
|
||
// Semantic.SkipEmbed. Not part of the on-disk YAML schema — it's
|
||
// populated by ConfigManager.GetRepoConfig so the indexer gets it
|
||
// through the same struct it already receives. Surface it to users
|
||
// under semantic.skip_embed, not under index.
|
||
SkipEmbed []SkipEmbedRule `mapstructure:"-" yaml:"-"`
|
||
// SkipSearch is the effective text-index skip rules resolved from
|
||
// Semantic.SkipSearch, same propagation pattern as SkipEmbed.
|
||
// Users configure this under semantic.skip_search; the indexer
|
||
// reads it here. Controls what goes into BM25/Bleve — unlike
|
||
// SkipEmbed it doesn't affect the graph or vector index.
|
||
SkipSearch []SkipEmbedRule `mapstructure:"-" yaml:"-"`
|
||
// IndexProse is the effective prose-indexing toggle resolved from
|
||
// Search.IndexProse -- same `-` (not on-disk) propagation pattern
|
||
// as SkipSearch. When false, Markdown KindDoc prose-section nodes
|
||
// are kept out of the BM25 search index. Defaults to true.
|
||
IndexProse bool `mapstructure:"-" yaml:"-"`
|
||
// MaxFileSize skips files larger than this during indexing. Zero
|
||
// (the default) disables the cap — full coverage is preferred so
|
||
// generated code like `*.pb.go`, schema files, and large data
|
||
// constants stay queryable. Users with very heavy generated /
|
||
// minified files that dominate parse time can set a cap (e.g.
|
||
// 2 MiB) via `.gortex.yaml` to trade coverage for speed. A cap
|
||
// that drops real symbols silently is a worse default than a
|
||
// slightly slower full index.
|
||
MaxFileSize int64 `mapstructure:"max_file_size" yaml:"max_file_size,omitempty"`
|
||
// MaxParseBytesInFlight bounds the total raw source bytes admitted
|
||
// into concurrent extraction at once. A weighted, bytes-in-flight
|
||
// semaphore admits each file by its size before it is read + parsed,
|
||
// so a cluster of large files (PDFs, office docs in a content repo)
|
||
// serialises instead of all workers materialising whole files and
|
||
// their parse trees simultaneously — the content-repo OOM class.
|
||
// Zero disables the cap; Default() sets a conservative non-zero budget.
|
||
MaxParseBytesInFlight int64 `mapstructure:"max_parse_bytes_in_flight" yaml:"max_parse_bytes_in_flight,omitempty"`
|
||
// IndexMinified controls whether bundled / minified build
|
||
// artifacts are indexed. Off by default: a minified bundle or a
|
||
// sourcemap is synthetic source — it has no meaningful symbols and
|
||
// only pollutes the graph and search results — so it is detected by
|
||
// content and skipped with a synthetic telemetry node. Set true to
|
||
// index such files anyway. Configured under `index.index_minified`.
|
||
IndexMinified bool `mapstructure:"index_minified" yaml:"index_minified,omitempty"`
|
||
// CrashIsolation runs tree-sitter extraction in worker
|
||
// subprocesses so a grammar SIGSEGV / OOM / hang on one
|
||
// pathological file is contained: the bad file is quarantined
|
||
// with Meta["parse_error"] and the index pass still completes.
|
||
// Off by default — the subprocess round-trip adds measurable
|
||
// overhead and an in-process index is the common case. Opt in via
|
||
// `.gortex.yaml::index::crash_isolation: true` or the
|
||
// GORTEX_PARSER_ISOLATION=1 environment override.
|
||
CrashIsolation bool `mapstructure:"crash_isolation" yaml:"crash_isolation,omitempty"`
|
||
// Merkle switches incremental re-index change detection from
|
||
// per-file mtime comparison to a BLAKE3 Merkle tree. The tree is
|
||
// content-addressed, so a file touched without a content change is
|
||
// not re-indexed, and an unchanged subtree is skipped wholesale.
|
||
// Off by default — mtime detection is cheaper when most touches
|
||
// are real edits. Opt in via `.gortex.yaml::index::merkle: true`
|
||
// or the GORTEX_MERKLE=1 environment override.
|
||
Merkle bool `mapstructure:"merkle" yaml:"merkle,omitempty"`
|
||
// MaxExtractMillis caps how long a single file's extraction may
|
||
// run. A file that exceeds the budget is skipped with a synthetic
|
||
// node carrying Meta["skipped_due_to_timeout"] instead of stalling
|
||
// the pass — the microsoft/TypeScript reallyLargeFile.ts class of
|
||
// pathological input. Zero (the default) disables the cap, for the
|
||
// same full-coverage reason MaxFileSize defaults off. Set
|
||
// generously (e.g. 10000) so only genuinely pathological files
|
||
// trip it. In crash-isolation mode it also bounds the worker
|
||
// round-trip.
|
||
MaxExtractMillis int `mapstructure:"max_extract_millis" yaml:"max_extract_millis,omitempty"`
|
||
// SynthesizeExternalCalls turns a call into an un-indexed third
|
||
// party (an npm/pip/cargo/maven/nuget package, or a sibling
|
||
// microservice) into an explicit graph terminal. Without it such a
|
||
// call edge stays an `unresolved::` placeholder with no destination
|
||
// node, and a call-chain walk silently stops there — losing the fact
|
||
// that the function reaches out to an external system at all. When
|
||
// on, the resolver synthesises a clearly-marked synthetic node per
|
||
// (ecosystem, import path) and retargets the call edge to it, so
|
||
// `get_call_chain` / `get_callers` keep the external hop visible and
|
||
// every call into the same package shares one stable, cross-repo
|
||
// identity node — `analyze kind=external_calls` then aggregates a
|
||
// service's whole external surface across repositories.
|
||
//
|
||
// Tri-state, default ON: a nil pointer (the key absent) resolves to
|
||
// enabled via ExternalCallSynthesisEnabledOrDefault, so external-call
|
||
// qualification is automatic for every language whose extractor lands
|
||
// calls on a dep/stdlib/external terminal (Go/Rust/Java/Python/C#/TS).
|
||
// Affordable by default because synthesis is incremental on the hot
|
||
// reindex path (only the edited file's terminals are re-materialised)
|
||
// and the disk backend pushes candidate-edge selection down to a
|
||
// partial-indexed query. Opt out per-repo with
|
||
// `.gortex.yaml::index::synthesize_external_calls: false` or the
|
||
// GORTEX_SYNTH_EXTERNAL_CALLS=0 environment override; language /
|
||
// stdlib calls are filtered out regardless so the synthetic nodes
|
||
// only ever name genuine third-party packages.
|
||
SynthesizeExternalCalls *bool `mapstructure:"synthesize_external_calls" yaml:"synthesize_external_calls,omitempty"`
|
||
// SynthesizeSpeculativeDispatch mints opt-in, best-guess `calls` edges for
|
||
// dynamic-dispatch blind spots (computed-member calls obj["foo"](),
|
||
// getattr, decorator registries). Unlike external-call synthesis it
|
||
// DEFAULTS OFF (tri-state, nil = off) because the edges are heuristic
|
||
// fan-outs; when on they ride a strictly-lower confidence tier and are
|
||
// hidden from every default query (opt in per query with
|
||
// include_speculative, or audit via `analyze kind=speculative`). Enable
|
||
// per-repo with `.gortex.yaml::index::synthesize_speculative_dispatch:
|
||
// true` or the GORTEX_SYNTH_SPECULATIVE=1 environment override.
|
||
SynthesizeSpeculativeDispatch *bool `mapstructure:"synthesize_speculative_dispatch" yaml:"synthesize_speculative_dispatch,omitempty"`
|
||
// ScopedGlobalPasses scopes the global inference passes (InferImplements /
|
||
// InferOverrides) on incremental reindex to only the types/interfaces a
|
||
// change can affect, instead of re-running the whole-graph type×interface
|
||
// cross product on every single-file edit. Add-parity with the full pass
|
||
// (it re-derives exactly the edges eviction dropped). Tri-state, DEFAULT
|
||
// ON. Set false (or GORTEX_INDEX_SCOPED_GLOBAL_PASSES=0) to restore the
|
||
// whole-graph behaviour.
|
||
ScopedGlobalPasses *bool `mapstructure:"scoped_global_passes" yaml:"scoped_global_passes,omitempty"`
|
||
// AffectedByReresolveMax caps how many referencing files a single
|
||
// save's affected-by re-resolution pass will re-resolve. When a
|
||
// file's symbol signatures change (or symbols are removed / change
|
||
// kind), the files that referenced those symbols are re-resolved so
|
||
// their edges and persisted reference facts track the new shape; a
|
||
// symbol with thousands of callers must not turn one save into a
|
||
// near-whole-graph resolve, so the affected set is truncated at this
|
||
// bound (truncation is logged with the dropped count). Zero (the
|
||
// default) uses the built-in cap of 200 files. Configured under
|
||
// `index.affected_by_reresolve_max` in .gortex.yaml.
|
||
AffectedByReresolveMax int `mapstructure:"affected_by_reresolve_max" yaml:"affected_by_reresolve_max,omitempty"`
|
||
// Transforms are pluggable pre-ingestion content processors. Each
|
||
// rewrites a matching file's bytes before the parser sees them —
|
||
// expanding minified bundles, normalising SVG/TOON, converting a
|
||
// PDF to markdown, etc. Empty by default.
|
||
Transforms []TransformRule `mapstructure:"transforms" yaml:"transforms,omitempty"`
|
||
// Grammars registers user-supplied tree-sitter grammars — drop-in
|
||
// languages Gortex was not compiled with. Each entry points at a
|
||
// compiled grammar shared object (.so / .dylib / .dll); see
|
||
// GrammarSpec. Empty by default. Configured under `index.grammars`
|
||
// in .gortex.yaml.
|
||
Grammars []GrammarSpec `mapstructure:"grammars" yaml:"grammars,omitempty"`
|
||
// Coverage gates the per-domain coverage extractors (todos,
|
||
// licenses, ownership, function shape, etc.). Each sub-block has
|
||
// its own default; an empty Coverage block means "use the
|
||
// documented per-domain defaults" — cheap structural domains on,
|
||
// expensive ones off.
|
||
Coverage CoverageConfig `mapstructure:"coverage" yaml:"coverage,omitempty"`
|
||
// HTTPClientAliases names project-defined wrapped HTTP-client
|
||
// functions so calls to them are recognised as HTTP consumer
|
||
// contracts (RoleConsumer) — without relying on the type-driven
|
||
// fetch/axios heuristics. Each entry is a bare function name (or
|
||
// receiver.method) that forwards a string-literal path to an
|
||
// underlying client, e.g. `apiGet`, `apiPost`, `client.request`.
|
||
// The contracts HTTP extractor mints an `http::METHOD::/path`
|
||
// consumer contract for every call to one of these names. The
|
||
// method is taken from the name's verb suffix (`apiGet` → GET,
|
||
// `apiPost` → POST, ...) when present, falling back to the first
|
||
// string-literal argument when the call passes the method
|
||
// explicitly (`apiCall('GET', '/users')`); the path is the first
|
||
// path-shaped string literal. Empty by default. Configured under
|
||
// `index.http_client_aliases` in .gortex.yaml.
|
||
HTTPClientAliases []string `mapstructure:"http_client_aliases" yaml:"http_client_aliases,omitempty"`
|
||
// ExtractorPlugins registers external post-parse extractor passes —
|
||
// the "add a custom extractor without forking Gortex" entry point.
|
||
// Each spec names a language + file extensions and an external
|
||
// command; matching files are piped (content on stdin,
|
||
// GORTEX_FILE_PATH in the env) to that command, which emits a JSON
|
||
// document of nodes and edges that Gortex folds into the graph. See
|
||
// ExtractorPluginSpec. Empty by default. Configured under
|
||
// `index.extractor_plugins` in .gortex.yaml.
|
||
ExtractorPlugins []ExtractorPluginSpec `mapstructure:"extractor_plugins" yaml:"extractor_plugins,omitempty"`
|
||
// FallbackChunkers registers declarative regex chunkers for
|
||
// languages Gortex has no tree-sitter grammar for — the "give a
|
||
// grammar-less language a coarse outline without writing Go" entry
|
||
// point. Each spec names a language + file extensions and a list of
|
||
// regex patterns; matching files yield one node per pattern match
|
||
// plus an EdgeDefines from the file. See FallbackChunkerSpec. Empty
|
||
// by default. Configured under `index.fallback_chunkers` in
|
||
// .gortex.yaml.
|
||
FallbackChunkers []FallbackChunkerSpec `mapstructure:"fallback_chunkers" yaml:"fallback_chunkers,omitempty"`
|
||
|
||
// EventBus declares producer/consumer boundaries for a bespoke event
|
||
// bus / SSE flow purely in config — no code change. Each spec matches
|
||
// call sites / decorators / interface bases and Gortex synthesizes real
|
||
// traversable provider↔consumer contract pairs (with dispatch guards)
|
||
// for the bus, so find_usages / trace_path / analyze pubsub all work on
|
||
// it. Empty by default. Configured under `index.event_bus` in
|
||
// .gortex.yaml; the CODEGRAPH_EVENT_CONFIG env var (a JSON list)
|
||
// overrides it for drop-in compatibility with pygraph/tsgraph.
|
||
EventBus []EventBusBoundarySpec `mapstructure:"event_bus" yaml:"event_bus,omitempty"`
|
||
|
||
// Content bounds admission of large non-source content / data
|
||
// artifacts — PDF / office documents and binary / columnar / vector
|
||
// data files — so a content-heavy corpus (a RAG repo of hundreds of
|
||
// decks, spreadsheets, and dataset shards) can't pull gigabytes of
|
||
// non-code files into the parse pipeline and OOM the indexer (#120).
|
||
// Documents over a per-file cap and (by default) all data assets are
|
||
// dropped at the walk with a skip-telemetry node, so they stay
|
||
// listable without being read or extracted. See
|
||
// ContentAdmissionConfig. Configured under `index.content`.
|
||
Content ContentAdmissionConfig `mapstructure:"content" yaml:"content,omitempty"`
|
||
|
||
// SkipUntrackedAssets drops document / data / image assets that git
|
||
// does not track (uncommitted working-tree files) during a full index.
|
||
// `.gitignore` is already honoured (respect_gitignore), but it can't
|
||
// catch files that are merely untracked — never `git add`ed and not in
|
||
// .gitignore — which is exactly how RAG corpora, downloaded datasets,
|
||
// and build outputs end up admitted (#120). When on, an untracked
|
||
// asset-class file is skipped at the walk with an `untracked_asset`
|
||
// telemetry node; untracked CODE is still indexed, so new / unsaved
|
||
// source keeps working. Off by default. Inert on a non-git repo or when
|
||
// `git ls-files` is unavailable (everything is admitted as before).
|
||
// Applies to the cold full-index walk; the incremental watcher path
|
||
// keeps the size / class caps only. Configured under
|
||
// `index.skip_untracked_assets`.
|
||
SkipUntrackedAssets bool `mapstructure:"skip_untracked_assets" yaml:"skip_untracked_assets,omitempty"`
|
||
}
|
||
|
||
// ContentAdmissionConfig gates which large non-source artifacts enter the
|
||
// index. The defaults keep the multimodal feature working for normal-size
|
||
// documents while bounding the corpus-admission memory blow-up that a
|
||
// content-heavy repo otherwise triggers.
|
||
type ContentAdmissionConfig struct {
|
||
// MaxDocumentBytes caps individual document assets — PDF, pptx, xlsx,
|
||
// plain text — that are ingested as searchable content (one KindDoc
|
||
// node per page / slide / sheet). A file larger than the cap is
|
||
// skipped at the walk with a `large_document` telemetry node instead
|
||
// of being read and extracted. Tri-state: >0 caps at that many bytes;
|
||
// 0 (absent) uses the built-in default (defaultMaxDocumentBytes,
|
||
// 10 MiB); <0 disables the cap (index documents of any size).
|
||
// Configured under `index.content.max_document_bytes`.
|
||
MaxDocumentBytes int64 `mapstructure:"max_document_bytes" yaml:"max_document_bytes,omitempty"`
|
||
// IndexData admits binary / columnar / vector data artifacts
|
||
// (.parquet, .npy, .npz, .lance, .arrow, .feather) as metadata-only
|
||
// nodes. Off by default: these are never code-intelligence content and
|
||
// in a RAG / data repo they dominate the admitted byte weight, so they
|
||
// are skipped at the walk with a `vector_data` telemetry node unless
|
||
// explicitly opted in. Configured under `index.content.index_data`.
|
||
IndexData bool `mapstructure:"index_data" yaml:"index_data,omitempty"`
|
||
// MaxDataBytes caps data assets when IndexData is on — a guard against
|
||
// admitting a multi-GB shard even when data indexing is wanted. Same
|
||
// tri-state as MaxDocumentBytes (>0 caps; 0 uses the built-in default,
|
||
// defaultMaxDataBytes; <0 disables the cap). Ignored when IndexData is
|
||
// off. Configured under `index.content.max_data_bytes`.
|
||
MaxDataBytes int64 `mapstructure:"max_data_bytes" yaml:"max_data_bytes,omitempty"`
|
||
}
|
||
|
||
// EffectiveMaxDocumentBytes resolves MaxDocumentBytes' tri-state into a
|
||
// concrete cap. capped is false when documents are admitted at any size
|
||
// (the field was set negative); otherwise limit is the active per-file cap.
|
||
func (c ContentAdmissionConfig) EffectiveMaxDocumentBytes() (limit int64, capped bool) {
|
||
switch {
|
||
case c.MaxDocumentBytes < 0:
|
||
return 0, false
|
||
case c.MaxDocumentBytes == 0:
|
||
return defaultMaxDocumentBytes, true
|
||
default:
|
||
return c.MaxDocumentBytes, true
|
||
}
|
||
}
|
||
|
||
// EffectiveMaxDataBytes resolves MaxDataBytes' tri-state into a concrete
|
||
// cap, used only when IndexData is on. capped is false when admitted data
|
||
// assets are uncapped (the field was set negative).
|
||
func (c ContentAdmissionConfig) EffectiveMaxDataBytes() (limit int64, capped bool) {
|
||
switch {
|
||
case c.MaxDataBytes < 0:
|
||
return 0, false
|
||
case c.MaxDataBytes == 0:
|
||
return defaultMaxDataBytes, true
|
||
default:
|
||
return c.MaxDataBytes, true
|
||
}
|
||
}
|
||
|
||
// EventBusBoundarySpec declares one producer or consumer boundary of a
|
||
// user-defined event bus / SSE flow. The schema is language-neutral and
|
||
// drop-in compatible with pygraph/tsgraph's CODEGRAPH_EVENT_CONFIG entries.
|
||
type EventBusBoundarySpec struct {
|
||
// Name groups producers and consumers of the same logical bus. A
|
||
// producer and consumer with the same Name + topic pair into an edge.
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
// Type is "producer" or "consumer".
|
||
Type string `mapstructure:"type" yaml:"type"`
|
||
// Callee is a dotted call suffix matched against producer/consumer call
|
||
// sites (e.g. "bus.publish", "producer.send"). Matched as a suffix so
|
||
// "self.producer.send(" matches "producer.send".
|
||
Callee string `mapstructure:"callee" yaml:"callee,omitempty"`
|
||
// CalleePattern is a looser substring match on the callee for SSE / hook
|
||
// forms (e.g. "EventSource", "useEventStream"). Alias: HookPattern.
|
||
CalleePattern string `mapstructure:"callee_pattern" yaml:"callee_pattern,omitempty"`
|
||
// HookPattern is an alias for CalleePattern (tsgraph compatibility).
|
||
HookPattern string `mapstructure:"hook_pattern" yaml:"hook_pattern,omitempty"`
|
||
// Decorator names a decorator that marks the decorated function as a
|
||
// consumer (e.g. "kafka_consumer"); the topic is read from its args.
|
||
Decorator string `mapstructure:"decorator" yaml:"decorator,omitempty"`
|
||
// Interface names a class base; every method of a class extending it is
|
||
// a consumer (paired on the bus wildcard topic).
|
||
Interface string `mapstructure:"interface" yaml:"interface,omitempty"`
|
||
// TopicArg names the argument carrying the topic / url that keys the
|
||
// producer↔consumer join: a positional index ("0") or a kwarg name
|
||
// ("topic"). Defaults to "topic".
|
||
TopicArg string `mapstructure:"topic_arg" yaml:"topic_arg,omitempty"`
|
||
// Guards, when true, extracts the consumer's first if/elif dispatch
|
||
// chain (field==value rules) onto the contract for routing queries.
|
||
Guards bool `mapstructure:"guards" yaml:"guards,omitempty"`
|
||
}
|
||
|
||
// GrammarSpec declares a user-supplied tree-sitter grammar to load at
|
||
// startup — a drop-in language Gortex was not compiled with. The
|
||
// grammar must be a compiled shared library (.so / .dylib / .dll)
|
||
// exporting the standard tree-sitter `tree_sitter_<language>` entry
|
||
// point, built against a compatible tree-sitter ABI.
|
||
type GrammarSpec struct {
|
||
// Language is the name the extractor registers under. A name that
|
||
// collides with a built-in extractor is skipped — built-ins win.
|
||
Language string `mapstructure:"language" yaml:"language"`
|
||
// Library is the path to the compiled grammar shared object. A
|
||
// relative path resolves against the working directory.
|
||
Library string `mapstructure:"library" yaml:"library"`
|
||
// Symbol overrides the C entry-point symbol. Defaults to
|
||
// `tree_sitter_<language>` with non-alphanumerics folded to `_`.
|
||
Symbol string `mapstructure:"symbol" yaml:"symbol,omitempty"`
|
||
// Extensions are the file extensions (leading dot) the grammar
|
||
// claims, e.g. [".foo", ".foobar"]. An extension already claimed
|
||
// by a built-in extractor is skipped.
|
||
Extensions []string `mapstructure:"extensions" yaml:"extensions"`
|
||
}
|
||
|
||
// TransformRule declares a pluggable pre-ingestion content transform.
|
||
// Before a matching file is parsed, its bytes are piped through the
|
||
// command (file content on stdin, transformed content on stdout). This
|
||
// is how non-native inputs reach the graph — minified bundles expanded,
|
||
// SVG/TOON normalised, a PDF converted to markdown, and so on.
|
||
type TransformRule struct {
|
||
// Name identifies the transform in logs.
|
||
Name string `mapstructure:"name" yaml:"name"`
|
||
// Extensions are the file extensions (with the dot, e.g. ".svg")
|
||
// this transform applies to. Empty means every file.
|
||
Extensions []string `mapstructure:"extensions" yaml:"extensions,omitempty"`
|
||
// Command is the transform program as argv. The file content is
|
||
// written to its stdin; its stdout replaces the content.
|
||
Command []string `mapstructure:"command" yaml:"command"`
|
||
// AsLanguage, when set, indexes matching files as this language
|
||
// even if their extension is not natively recognised — a rule with
|
||
// extensions [".pdf"] + as_language "markdown" lets a PDF→markdown
|
||
// command feed the markdown extractor.
|
||
AsLanguage string `mapstructure:"as_language" yaml:"as_language,omitempty"`
|
||
// TimeoutMillis bounds the transform subprocess; 0 uses a default.
|
||
TimeoutMillis int `mapstructure:"timeout_millis" yaml:"timeout_millis,omitempty"`
|
||
}
|
||
|
||
// ExtractorPluginSpec declares an external post-parse extractor pass —
|
||
// the config-driven SPI for adding a custom extractor without forking
|
||
// Gortex. Files whose extension matches are piped (content on stdin,
|
||
// GORTEX_FILE_PATH carrying the path in the env) to the command, which
|
||
// must emit a JSON document of the shape:
|
||
//
|
||
// {"nodes":[{"id","kind","name","file_path","start_line","end_line",
|
||
// "language","meta":{...}}],
|
||
// "edges":[{"from","to","kind","file_path","line","meta":{...}}]}
|
||
//
|
||
// Each node whose Kind is a valid graph node kind becomes a graph.Node;
|
||
// each edge becomes a graph.Edge. The owning file node is always
|
||
// emitted. A non-zero exit, malformed JSON, or a timeout degrades to
|
||
// just the file node (the index never fails). A language or extension
|
||
// that collides with a built-in extractor is skipped — built-ins win.
|
||
type ExtractorPluginSpec struct {
|
||
// Language is the name the extractor registers under. A name that
|
||
// collides with a built-in extractor is skipped.
|
||
Language string `mapstructure:"language" yaml:"language"`
|
||
// Extensions are the file extensions (leading dot) the plugin
|
||
// claims, e.g. [".foo"]. An extension already claimed by a built-in
|
||
// extractor is skipped.
|
||
Extensions []string `mapstructure:"extensions" yaml:"extensions"`
|
||
// Command is the plugin program (argv[0]). The file content is
|
||
// written to its stdin; GORTEX_FILE_PATH names the file in the env.
|
||
Command string `mapstructure:"command" yaml:"command"`
|
||
// Args are the trailing arguments passed to Command.
|
||
Args []string `mapstructure:"args" yaml:"args,omitempty"`
|
||
// TimeoutMs bounds the plugin subprocess; 0 uses a default.
|
||
TimeoutMs int `mapstructure:"timeout_ms" yaml:"timeout_ms,omitempty"`
|
||
}
|
||
|
||
// FallbackChunkerSpec declares a declarative regex chunker for a
|
||
// grammar-less language — the config-driven SPI for giving a language
|
||
// Gortex has no tree-sitter grammar a coarse symbol outline without
|
||
// writing Go. Files whose extension matches are scanned with each
|
||
// pattern; every match emits a node of the pattern's kind (validated
|
||
// against the graph node kinds) plus an EdgeDefines from the file. A
|
||
// language or extension that collides with a built-in extractor is
|
||
// skipped — built-ins win.
|
||
type FallbackChunkerSpec struct {
|
||
// Language is the name the chunker registers under. A name that
|
||
// collides with a built-in extractor is skipped.
|
||
Language string `mapstructure:"language" yaml:"language"`
|
||
// Extensions are the file extensions (leading dot) the chunker
|
||
// claims. An extension already claimed by a built-in extractor is
|
||
// skipped.
|
||
Extensions []string `mapstructure:"extensions" yaml:"extensions"`
|
||
// Patterns are the regex rules applied to a matching file's content.
|
||
Patterns []ChunkPattern `mapstructure:"patterns" yaml:"patterns"`
|
||
}
|
||
|
||
// ChunkPattern is a single regex rule of a FallbackChunkerSpec. Each
|
||
// match yields one node of Kind named by the NameGroup-th capture.
|
||
type ChunkPattern struct {
|
||
// Kind is the graph node kind to emit (e.g. "function", "type").
|
||
// A kind that is not a valid graph node kind is skipped.
|
||
Kind string `mapstructure:"kind" yaml:"kind"`
|
||
// Regex is the (Go-syntax) pattern matched against the file content.
|
||
// A pattern that fails to compile skips the whole chunker spec.
|
||
Regex string `mapstructure:"regex" yaml:"regex"`
|
||
// NameGroup is the capture-group index whose text names the node.
|
||
// Zero (the default) uses group 1 — the first parenthesised group.
|
||
NameGroup int `mapstructure:"name_group" yaml:"name_group,omitempty"`
|
||
}
|
||
|
||
// CoverageConfig collects the per-domain coverage extraction gates.
|
||
// Each sub-block is independently shippable and gated.
|
||
//
|
||
// Defaults (per-domain Enabled value when not set in YAML):
|
||
//
|
||
// - FunctionShape: true (params/returns/generics/closures — Phase 1)
|
||
// - Concurrency: true (closures already covered by FunctionShape;
|
||
// this gates EdgeSpawns / channel I/O)
|
||
// - Constants: true (cheap, structural)
|
||
// - TypeShape: true (aliases vs newtypes vs composition)
|
||
// - Codegen: true (// Code generated markers)
|
||
// - Todos: true (comment scanner)
|
||
// - Ownership: true (CODEOWNERS — only emits when file present)
|
||
// - Licenses: true (SPDX header scan)
|
||
// - Modules: true (lockfile parse — cheap)
|
||
// - Configs: false (recognizers per provider; opt-in)
|
||
// - Flags: false (auto-on if a provider client is detected)
|
||
// - Observability: false (logging/metric/trace event names)
|
||
// - Pubsub: false (event pub/sub publish/subscribe edges)
|
||
// - SQL: false (Phase 3 — noisy and slow)
|
||
// - Fixtures: true (testdata path detection)
|
||
// - CrossLanguage: false (cgo / wasm-bindgen)
|
||
// - Clones: true (MinHash + LSH near-duplicate detection)
|
||
//
|
||
// Setting any leaf Enabled explicitly overrides the default.
|
||
type CoverageConfig struct {
|
||
FunctionShape DomainToggle `mapstructure:"function_shape" yaml:"function_shape,omitempty"`
|
||
Concurrency DomainToggle `mapstructure:"concurrency" yaml:"concurrency,omitempty"`
|
||
Constants DomainToggle `mapstructure:"constants" yaml:"constants,omitempty"`
|
||
TypeShape DomainToggle `mapstructure:"type_shape" yaml:"type_shape,omitempty"`
|
||
Codegen DomainToggle `mapstructure:"codegen" yaml:"codegen,omitempty"`
|
||
Todos TodoConfig `mapstructure:"todos" yaml:"todos,omitempty"`
|
||
Ownership DomainToggle `mapstructure:"ownership" yaml:"ownership,omitempty"`
|
||
Licenses DomainToggle `mapstructure:"licenses" yaml:"licenses,omitempty"`
|
||
Modules DomainToggle `mapstructure:"modules" yaml:"modules,omitempty"`
|
||
Configs DomainToggle `mapstructure:"configs" yaml:"configs,omitempty"`
|
||
Flags FlagConfig `mapstructure:"flags" yaml:"flags,omitempty"`
|
||
Observability DomainToggle `mapstructure:"observability" yaml:"observability,omitempty"`
|
||
Pubsub DomainToggle `mapstructure:"pubsub" yaml:"pubsub,omitempty"`
|
||
SQL SQLConfig `mapstructure:"sql" yaml:"sql,omitempty"`
|
||
Fixtures DomainToggle `mapstructure:"fixtures" yaml:"fixtures,omitempty"`
|
||
CrossLanguage DomainToggle `mapstructure:"cross_language" yaml:"cross_language,omitempty"`
|
||
Clones ClonesConfig `mapstructure:"clones" yaml:"clones,omitempty"`
|
||
}
|
||
|
||
// ClonesConfig gates MinHash + LSH near-duplicate ("clone") detection.
|
||
// When enabled, the indexer stamps a 64-slot MinHash signature on every
|
||
// substantial function/method node at parse time and a graph-wide pass
|
||
// emits EdgeSimilarTo edges between bodies whose estimated Jaccard
|
||
// similarity is at or above Threshold. Default-on: signature
|
||
// computation is a cheap per-function tokenise + hash, and the LSH pass
|
||
// is near-linear.
|
||
type ClonesConfig struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
// Threshold is the Jaccard similarity at or above which a candidate
|
||
// pair is recorded as a clone. Zero (unset) falls back to the
|
||
// clones package default (0.82). Values are clamped to (0, 1].
|
||
Threshold float64 `mapstructure:"threshold" yaml:"threshold,omitempty"`
|
||
}
|
||
|
||
// DomainToggle is the minimal config for a domain whose only knob is
|
||
// on/off plus an optional language allow-list. The Enabled field uses
|
||
// a tri-state pointer so we can distinguish "user set false" from
|
||
// "user did not set" (and apply the per-domain default for the
|
||
// latter). The language list, when non-empty, restricts extraction to
|
||
// the listed source languages.
|
||
type DomainToggle struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
Languages []string `mapstructure:"languages" yaml:"languages,omitempty"`
|
||
}
|
||
|
||
// TodoConfig configures the TODO scanner. Tags is the set of
|
||
// recognised marker tokens (default: TODO, FIXME, HACK, XXX, NOTE);
|
||
// MaxText caps the stored text length (default 200) so a wall of
|
||
// commented-out code in a TODO doesn't bloat the graph.
|
||
type TodoConfig struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
Tags []string `mapstructure:"tags" yaml:"tags,omitempty"`
|
||
MaxText int `mapstructure:"max_text" yaml:"max_text,omitempty"`
|
||
}
|
||
|
||
// FlagConfig configures feature-flag recognition. Recognizers is a
|
||
// list of (provider, function-name) pairs to treat as flag checks;
|
||
// the built-in recognizers cover GrowthBook, LaunchDarkly, Unleash by
|
||
// default.
|
||
type FlagConfig struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
Recognizers []FlagRecognizer `mapstructure:"recognizers" yaml:"recognizers,omitempty"`
|
||
}
|
||
|
||
// FlagRecognizer maps a fully-qualified function name to a flag
|
||
// provider and operation. Op ∈ read|write|register.
|
||
type FlagRecognizer struct {
|
||
Provider string `mapstructure:"provider" yaml:"provider"`
|
||
Func string `mapstructure:"func" yaml:"func"`
|
||
Op string `mapstructure:"op" yaml:"op,omitempty"`
|
||
}
|
||
|
||
// SQLConfig gates SQL schema extraction. Default-off because SQL
|
||
// parsing is slow and string-literal SQL produces false positives.
|
||
type SQLConfig struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
Dialect string `mapstructure:"dialect" yaml:"dialect,omitempty"`
|
||
Migrations SQLMigrations `mapstructure:"migrations" yaml:"migrations,omitempty"`
|
||
ORM SQLOrm `mapstructure:"orm" yaml:"orm,omitempty"`
|
||
StringLiterals SQLStringLits `mapstructure:"string_literals" yaml:"string_literals,omitempty"`
|
||
}
|
||
|
||
type SQLMigrations struct {
|
||
Paths []string `mapstructure:"paths" yaml:"paths,omitempty"`
|
||
Format string `mapstructure:"format" yaml:"format,omitempty"`
|
||
}
|
||
|
||
type SQLOrm struct {
|
||
Detect []string `mapstructure:"detect" yaml:"detect,omitempty"`
|
||
}
|
||
|
||
type SQLStringLits struct {
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
MinConfidence string `mapstructure:"min_confidence" yaml:"min_confidence,omitempty"`
|
||
}
|
||
|
||
// coverageDomainDefault is the per-domain default that applies when a
|
||
// user has not explicitly set Enabled in their YAML. Cheap structural
|
||
// domains default on; expensive or noisy domains default off. See the
|
||
// CoverageConfig doc comment for the canonical list.
|
||
var coverageDomainDefault = map[string]bool{
|
||
"function_shape": true,
|
||
"concurrency": true,
|
||
"constants": true,
|
||
"type_shape": true,
|
||
"codegen": true,
|
||
"todos": true,
|
||
"ownership": true,
|
||
"licenses": true,
|
||
"modules": true,
|
||
"configs": false,
|
||
"flags": false,
|
||
"observability": false,
|
||
"pubsub": false,
|
||
"sql": false,
|
||
"fixtures": true,
|
||
"cross_language": false,
|
||
"clones": true,
|
||
}
|
||
|
||
// resolveDomainEnabled returns the effective Enabled flag for a
|
||
// domain — explicit YAML setting if present, else the documented
|
||
// default. Used by IsCoverageEnabled and the per-domain accessors.
|
||
func resolveDomainEnabled(explicit *bool, domain string) bool {
|
||
if explicit != nil {
|
||
return *explicit
|
||
}
|
||
return coverageDomainDefault[domain]
|
||
}
|
||
|
||
// IsCoverageEnabled reports whether a coverage domain's extractor
|
||
// should run for this Config. Pass a domain string from the
|
||
// CoverageConfig YAML field names: "function_shape", "todos",
|
||
// "licenses", etc. Unknown domain strings return false.
|
||
func (c *Config) IsCoverageEnabled(domain string) bool {
|
||
return c.Index.Coverage.IsEnabled(domain)
|
||
}
|
||
|
||
// IsEnabled is the IndexConfig-level form of IsCoverageEnabled. The
|
||
// indexer holds an IndexConfig directly (not the parent Config) so
|
||
// the gate accessor lives here too — keeps the call-site short and
|
||
// avoids passing the whole Config around for one boolean check.
|
||
func (cov CoverageConfig) IsEnabled(domain string) bool {
|
||
switch domain {
|
||
case "function_shape":
|
||
return resolveDomainEnabled(cov.FunctionShape.Enabled, domain)
|
||
case "concurrency":
|
||
return resolveDomainEnabled(cov.Concurrency.Enabled, domain)
|
||
case "constants":
|
||
return resolveDomainEnabled(cov.Constants.Enabled, domain)
|
||
case "type_shape":
|
||
return resolveDomainEnabled(cov.TypeShape.Enabled, domain)
|
||
case "codegen":
|
||
return resolveDomainEnabled(cov.Codegen.Enabled, domain)
|
||
case "todos":
|
||
return resolveDomainEnabled(cov.Todos.Enabled, domain)
|
||
case "ownership":
|
||
return resolveDomainEnabled(cov.Ownership.Enabled, domain)
|
||
case "licenses":
|
||
return resolveDomainEnabled(cov.Licenses.Enabled, domain)
|
||
case "modules":
|
||
return resolveDomainEnabled(cov.Modules.Enabled, domain)
|
||
case "configs":
|
||
return resolveDomainEnabled(cov.Configs.Enabled, domain)
|
||
case "flags":
|
||
return resolveDomainEnabled(cov.Flags.Enabled, domain)
|
||
case "observability":
|
||
return resolveDomainEnabled(cov.Observability.Enabled, domain)
|
||
case "pubsub":
|
||
return resolveDomainEnabled(cov.Pubsub.Enabled, domain)
|
||
case "sql":
|
||
return resolveDomainEnabled(cov.SQL.Enabled, domain)
|
||
case "fixtures":
|
||
return resolveDomainEnabled(cov.Fixtures.Enabled, domain)
|
||
case "cross_language":
|
||
return resolveDomainEnabled(cov.CrossLanguage.Enabled, domain)
|
||
case "clones":
|
||
return resolveDomainEnabled(cov.Clones.Enabled, domain)
|
||
}
|
||
return false
|
||
}
|
||
|
||
// ClonesThreshold returns the configured Jaccard similarity threshold
|
||
// for clone detection, or 0 when the user has not set one (callers
|
||
// then fall back to the clones package default). Out-of-range values
|
||
// are clamped to (0, 1].
|
||
func (cov CoverageConfig) ClonesThreshold() float64 {
|
||
t := cov.Clones.Threshold
|
||
if t <= 0 {
|
||
return 0
|
||
}
|
||
if t > 1 {
|
||
return 1
|
||
}
|
||
return t
|
||
}
|
||
|
||
// TodoTags returns the configured TODO tag set, or the default set
|
||
// when the user has not provided one. The defaults match the spec
|
||
// (TODO, FIXME, HACK, XXX, NOTE).
|
||
func (c *Config) TodoTags() []string {
|
||
if tags := c.Index.Coverage.Todos.Tags; len(tags) > 0 {
|
||
return tags
|
||
}
|
||
return []string{"TODO", "FIXME", "HACK", "XXX", "NOTE"}
|
||
}
|
||
|
||
// TodoMaxText returns the configured cap on stored TODO text, or the
|
||
// default of 200 characters.
|
||
func (c *Config) TodoMaxText() int {
|
||
if n := c.Index.Coverage.Todos.MaxText; n > 0 {
|
||
return n
|
||
}
|
||
return 200
|
||
}
|
||
|
||
type WatchConfig struct {
|
||
Enabled bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
Paths []string `mapstructure:"paths" yaml:"paths,omitempty"`
|
||
DebounceMs int `mapstructure:"debounce_ms" yaml:"debounce_ms,omitempty"`
|
||
// Exclude is deprecated — use top-level Config.Exclude instead.
|
||
// Kept for one release as a fallback merged into the unified list.
|
||
Exclude []string `mapstructure:"exclude" yaml:"exclude,omitempty"`
|
||
|
||
// StormThreshold — when more than this many events arrive within
|
||
// StormWindowMs, the watcher switches from per-file debounced
|
||
// patching to a batched reconcile that defers resolver + search
|
||
// rebuild until a quiet period has passed. Protects against event
|
||
// floods from bulk operations: `rsync`, `npm install`, branch
|
||
// checkout, bulk format-on-save, find-and-replace across a repo.
|
||
// Zero disables storm mode (pure per-file behaviour).
|
||
StormThreshold int `mapstructure:"storm_threshold" yaml:"storm_threshold,omitempty"`
|
||
// StormWindowMs is the sliding window over which events are counted
|
||
// against StormThreshold. Defaults to 500.
|
||
StormWindowMs int `mapstructure:"storm_window_ms" yaml:"storm_window_ms,omitempty"`
|
||
// StormQuietPeriodMs is how long the watcher waits for no events
|
||
// before draining the batch. Defaults to 500.
|
||
StormQuietPeriodMs int `mapstructure:"storm_quiet_period_ms" yaml:"storm_quiet_period_ms,omitempty"`
|
||
}
|
||
|
||
type QueryConfig struct {
|
||
DefaultDepth int `mapstructure:"default_depth" yaml:"default_depth,omitempty"`
|
||
MaxDepth int `mapstructure:"max_depth" yaml:"max_depth,omitempty"`
|
||
}
|
||
|
||
type ScopeConfig struct {
|
||
IntentDefaults bool `mapstructure:"intent_defaults" yaml:"intent_defaults,omitempty"`
|
||
}
|
||
|
||
// MergeEnv overlays the scope-specific environment knobs on top of
|
||
// file/default config values. Invalid values are ignored so a typo does not
|
||
// silently disable scoped queries.
|
||
func (c ScopeConfig) MergeEnv() ScopeConfig {
|
||
switch strings.ToLower(strings.TrimSpace(os.Getenv("GORTEX_SCOPE_INTENT_DEFAULTS"))) {
|
||
case "0", "false", "no":
|
||
c.IntentDefaults = false
|
||
case "1", "true", "yes":
|
||
c.IntentDefaults = true
|
||
}
|
||
return c
|
||
}
|
||
|
||
// SearchConfig configures the I13 11-signal rerank pipeline that
|
||
// orders `search_symbols` / `winnow_symbols` results. The Weights
|
||
// map is keyed by canonical signal name (rerank.SignalBM25,
|
||
// rerank.SignalSemantic, …) and overrides the tuned defaults
|
||
// returned by rerank.DefaultWeights(). Missing keys keep the
|
||
// default weight; setting a key to 0 disables that signal.
|
||
// FederationConfig is the .gortex.yaml `federation:` block. All knobs are
|
||
// optional; an unset field uses the daemon's built-in default.
|
||
type FederationConfig struct {
|
||
PerRemoteTimeoutMs int `mapstructure:"per_remote_timeout_ms" yaml:"per_remote_timeout_ms,omitempty"`
|
||
BudgetMs int `mapstructure:"budget_ms" yaml:"budget_ms,omitempty"`
|
||
BreakerThreshold int `mapstructure:"breaker_threshold" yaml:"breaker_threshold,omitempty"`
|
||
BreakerCooldownMs int `mapstructure:"breaker_cooldown_ms" yaml:"breaker_cooldown_ms,omitempty"`
|
||
NameKeyedFallback bool `mapstructure:"name_keyed_fallback" yaml:"name_keyed_fallback,omitempty"`
|
||
// Edges is the cross-daemon proxy-edge minting block. Off by
|
||
// default — federation stays read-only fan-out only.
|
||
Edges FederationEdgesConfig `mapstructure:"edges" yaml:"edges,omitempty"`
|
||
}
|
||
|
||
// FederationEdgesConfig is the `federation.edges` block — the
|
||
// cross-daemon proxy-node edge feature. Research-grade and
|
||
// off by default; none of the mint/hydrate paths run unless IsEnabled().
|
||
type FederationEdgesConfig struct {
|
||
// Enabled turns on proxy-node minting + lazy hydration.
|
||
Enabled bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
// TTLMs is the proxy-node neighbour-cache TTL in ms (default 5m).
|
||
TTLMs int `mapstructure:"ttl_ms" yaml:"ttl_ms,omitempty"`
|
||
// MaxProxyNodes is the hard heap bound across all remotes (default
|
||
// 5000); overflow refuses the mint.
|
||
MaxProxyNodes int `mapstructure:"max_proxy_nodes" yaml:"max_proxy_nodes,omitempty"`
|
||
// HydrateDepth is the neighbour rings pulled per access (default 1).
|
||
HydrateDepth int `mapstructure:"hydrate_depth" yaml:"hydrate_depth,omitempty"`
|
||
}
|
||
|
||
// IsEnabled reports whether proxy edges are on, honouring the
|
||
// GORTEX_FEDERATION_EDGES env override (1/true) over the config field.
|
||
func (c FederationEdgesConfig) IsEnabled() bool {
|
||
if v := strings.TrimSpace(os.Getenv("GORTEX_FEDERATION_EDGES")); v != "" {
|
||
return v == "1" || strings.EqualFold(v, "true")
|
||
}
|
||
return c.Enabled
|
||
}
|
||
|
||
// TTL is the proxy-node neighbour-cache TTL (default 5m).
|
||
func (c FederationEdgesConfig) TTL() time.Duration {
|
||
if c.TTLMs > 0 {
|
||
return time.Duration(c.TTLMs) * time.Millisecond
|
||
}
|
||
return 5 * time.Minute
|
||
}
|
||
|
||
// MaxNodes is the proxy-node heap bound across all remotes (default 5000).
|
||
func (c FederationEdgesConfig) MaxNodes() int {
|
||
if c.MaxProxyNodes > 0 {
|
||
return c.MaxProxyNodes
|
||
}
|
||
return 5000
|
||
}
|
||
|
||
// Depth is the neighbour rings pulled per hydration (default 1).
|
||
func (c FederationEdgesConfig) Depth() int {
|
||
if c.HydrateDepth > 0 {
|
||
return c.HydrateDepth
|
||
}
|
||
return 1
|
||
}
|
||
|
||
type SearchConfig struct {
|
||
// Weights overrides per-signal scoring weights. Canonical names:
|
||
// bm25, semantic, fan_in, hits, fan_out, churn, co_change,
|
||
// community, minhash, api_signature, type_signature, recency,
|
||
// feedback, file_coherence, path_penalty, definition_bias,
|
||
// source_bias, provenance, proximity.
|
||
Weights map[string]float64 `mapstructure:"weights" yaml:"weights,omitempty"`
|
||
|
||
// KeywordSoupRewrite controls how `search_symbols` handles a
|
||
// degenerate boolean / OR-soup query (`A OR B OR 'no access'`).
|
||
// - "split" (default): split the soup on its boolean operators
|
||
// and run a BM25 OR-merge over the disjuncts; LLM expansion is
|
||
// suppressed and a `query_advice` nudge rides on the response.
|
||
// - "nudge": leave retrieval unchanged but still attach the
|
||
// `query_advice` nudge.
|
||
// - "off": disable soup handling entirely.
|
||
// An empty value is treated as "split".
|
||
KeywordSoupRewrite string `mapstructure:"keyword_soup_rewrite" yaml:"keyword_soup_rewrite,omitempty"`
|
||
|
||
// EquivalenceClasses enables deterministic, LLM-free query
|
||
// expansion through the curated software-concept synonym table
|
||
// plus the per-repo auto-mined concept vocabulary. On by default
|
||
// (the pointer is nil-checked: nil means "on"). Set it false to
|
||
// disable equivalence expansion entirely.
|
||
EquivalenceClasses *bool `mapstructure:"equivalence_classes" yaml:"equivalence_classes,omitempty"`
|
||
|
||
// EquivalenceExtra adds repo-custom synonym classes to the curated
|
||
// equivalence table. Each entry maps a class label to its member
|
||
// words; the label itself joins the class. A label that names a
|
||
// curated word extends that curated class rather than forking it.
|
||
EquivalenceExtra map[string][]string `mapstructure:"equivalence_extra" yaml:"equivalence_extra,omitempty"`
|
||
|
||
// IndexProse controls whether Markdown prose-section (KindDoc)
|
||
// nodes are fed into the BM25 search index, so search_symbols
|
||
// with corpus:"docs" / "all" can return documentation hits. On
|
||
// by default (a nil pointer means "on"). Set false to keep prose
|
||
// out of the index entirely.
|
||
IndexProse *bool `mapstructure:"index_prose" yaml:"index_prose,omitempty"`
|
||
|
||
// VocabAnchoredExpansion sets the server-wide default for the
|
||
// search_symbols `vocab_anchored` argument: when on, the LLM
|
||
// query-expander's freely-invented synonyms are post-filtered to
|
||
// the words that actually appear in this repo's symbol names
|
||
// before they feed the BM25 OR-merge, so a model that hallucinates
|
||
// a plausible-but-absent term can't dilute the candidate pool. Off
|
||
// by default (a nil pointer means "off") -- the per-call argument
|
||
// is the primary control; this only changes the default when the
|
||
// argument is omitted. Degrades to unconstrained expansion when
|
||
// the repo's mined vocabulary is empty.
|
||
VocabAnchoredExpansion *bool `mapstructure:"vocab_anchored_expansion" yaml:"vocab_anchored_expansion,omitempty"`
|
||
|
||
// CosineRerank enables the post-rerank exact-cosine refinement
|
||
// stage: after the 11-signal rerank produces the ranked order,
|
||
// the top results are re-scored by exact cosine similarity
|
||
// between the query's embedding and each candidate's stored
|
||
// embedding, recovering the precise semantic distance the
|
||
// rank-based SemanticSignal discards. On by default (a nil
|
||
// pointer means "on"); the stage is a no-op whenever the vector
|
||
// channel is inactive (no embedder, no stored vectors, or the
|
||
// query fails to embed), so enabling it can never regress a
|
||
// text-only search. Set false to keep the pure rank-fusion order.
|
||
CosineRerank *bool `mapstructure:"cosine_rerank" yaml:"cosine_rerank,omitempty"`
|
||
}
|
||
|
||
// Keyword-soup rewrite modes for SearchConfig.KeywordSoupRewrite.
|
||
const (
|
||
KeywordSoupSplit = "split"
|
||
KeywordSoupNudge = "nudge"
|
||
KeywordSoupOff = "off"
|
||
)
|
||
|
||
// EquivalenceClassesEnabled reports whether deterministic
|
||
// equivalence-class query expansion is on. It defaults to true --
|
||
// a nil EquivalenceClasses pointer (the unset state) means enabled.
|
||
func (c SearchConfig) EquivalenceClassesEnabled() bool {
|
||
return c.EquivalenceClasses == nil || *c.EquivalenceClasses
|
||
}
|
||
|
||
// IndexProseEnabled reports whether Markdown prose-section nodes are
|
||
// indexed for search. Defaults to true -- a nil IndexProse pointer
|
||
// (the unset state) means enabled.
|
||
func (c SearchConfig) IndexProseEnabled() bool {
|
||
return c.IndexProse == nil || *c.IndexProse
|
||
}
|
||
|
||
// CosineRerankEnabled reports whether the post-rerank exact-cosine
|
||
// refinement stage is on. Defaults to true -- a nil CosineRerank
|
||
// pointer (the unset state) means enabled. The stage still no-ops
|
||
// when the vector channel is unavailable, so "enabled" is a
|
||
// permission, not a guarantee that it runs.
|
||
func (c SearchConfig) CosineRerankEnabled() bool {
|
||
return c.CosineRerank == nil || *c.CosineRerank
|
||
}
|
||
|
||
// VocabAnchoredExpansionDefault reports the server-wide default for
|
||
// the search_symbols `vocab_anchored` argument when the caller omits
|
||
// it. Defaults to false -- a nil VocabAnchoredExpansion pointer (the
|
||
// unset state) means off, so expansion stays unconstrained unless a
|
||
// caller (or this config) opts in.
|
||
func (c SearchConfig) VocabAnchoredExpansionDefault() bool {
|
||
return c.VocabAnchoredExpansion != nil && *c.VocabAnchoredExpansion
|
||
}
|
||
|
||
// EffectiveKeywordSoupRewrite folds the empty default into the
|
||
// canonical "split" mode and lower-cases the value, so callers can
|
||
// switch on it without re-normalising.
|
||
func (c SearchConfig) EffectiveKeywordSoupRewrite() string {
|
||
switch v := strings.ToLower(strings.TrimSpace(c.KeywordSoupRewrite)); v {
|
||
case "", KeywordSoupSplit:
|
||
return KeywordSoupSplit
|
||
case KeywordSoupNudge:
|
||
return KeywordSoupNudge
|
||
case KeywordSoupOff:
|
||
return KeywordSoupOff
|
||
default:
|
||
return KeywordSoupSplit
|
||
}
|
||
}
|
||
|
||
// EmbeddingConfig controls the semantic-search vector channel: which
|
||
// embedding provider builds the per-symbol vectors, and the chunking /
|
||
// concurrency knobs the indexer uses while building the vector index.
|
||
//
|
||
// Semantic search is a *fusion signal* layered alongside BM25 — the
|
||
// HybridBackend down-weights the vector channel for identifier-shaped
|
||
// queries — never a replacement for text search. The default provider
|
||
// is `static` (baked GloVe word vectors): it needs zero download and
|
||
// is CPU-only. As of the lean-index default, the static provider no
|
||
// longer builds a vector index automatically — FTS5/BM25 text search
|
||
// serves the default, and the semantic channel turns on when a real
|
||
// `local`/`api` provider (or `embedding.enabled: true`) is configured.
|
||
type EmbeddingConfig struct {
|
||
// Enabled is tri-state. A nil pointer means "not configured" —
|
||
// the vector channel is then built only when a real `local`/`api`
|
||
// provider is configured (the static default stays text-only). An
|
||
// explicit `embedding.enabled: false` turns the vector channel off;
|
||
// `true` forces it on, building whatever provider is configured
|
||
// (including the static one). Pointer so the loader can tell
|
||
// "absent" from "explicitly false", mirroring RespectGitignore.
|
||
Enabled *bool `mapstructure:"enabled" yaml:"enabled,omitempty"`
|
||
|
||
// Provider selects the embedding backend: `static` (baked GloVe,
|
||
// the default), `local` (best available transformer — Hugot
|
||
// MiniLM, auto-downloads ~87 MB on first use), or `api` (an
|
||
// external Ollama / OpenAI-compatible embedding endpoint). An
|
||
// empty value is treated as `static`.
|
||
Provider string `mapstructure:"provider" yaml:"provider,omitempty"`
|
||
|
||
// APIURL is the embedding endpoint base URL, used only when
|
||
// Provider is `api`. Ollama vs OpenAI wire format is auto-detected
|
||
// from the URL.
|
||
APIURL string `mapstructure:"api_url" yaml:"api_url,omitempty"`
|
||
|
||
// APIModel is the model name passed to the `api` provider. Empty
|
||
// lets the provider pick its format-appropriate default
|
||
// (nomic-embed-text for Ollama, text-embedding-3-small for OpenAI).
|
||
APIModel string `mapstructure:"api_model" yaml:"api_model,omitempty"`
|
||
|
||
// MaxSymbols overrides the indexer's hard cap on how many symbols
|
||
// are embedded into the vector index. Zero keeps the built-in
|
||
// default. Above the cap the vector channel is skipped and BM25
|
||
// alone serves search — an OOM during index is worse than a
|
||
// missing semantic boost.
|
||
MaxSymbols int `mapstructure:"max_symbols" yaml:"max_symbols,omitempty"`
|
||
|
||
// ChunkThresholdLines is the source-span line count above which a
|
||
// symbol is split into AST windows before embedding instead of
|
||
// being embedded as a single metadata-only vector. Zero keeps the
|
||
// built-in default (~60).
|
||
ChunkThresholdLines int `mapstructure:"chunk_threshold_lines" yaml:"chunk_threshold_lines,omitempty"`
|
||
|
||
// ChunkWindowLines caps the line span of each AST window emitted
|
||
// by the sub-chunker. Zero keeps the built-in default (~40).
|
||
ChunkWindowLines int `mapstructure:"chunk_window_lines" yaml:"chunk_window_lines,omitempty"`
|
||
|
||
// APIConcurrency bounds how many embedding requests the indexer
|
||
// issues in parallel against an `api` provider. Zero keeps the
|
||
// built-in default (4). Only the `api` provider runs concurrently —
|
||
// in-process transformer backends serialize on an inference mutex,
|
||
// so the pool would give them no speedup.
|
||
APIConcurrency int `mapstructure:"api_concurrency" yaml:"api_concurrency,omitempty"`
|
||
|
||
// Variant names a specific local transformer model to load when
|
||
// Provider is `local` -- a key from embedding.KnownHugotVariants
|
||
// (e.g. `fp32`, `bge_small`, `jina_code`). A non-empty Variant
|
||
// pins that exact model instead of the auto-selected default
|
||
// backend. Empty preserves the current default-selection
|
||
// behaviour. Ignored for the `static` and `api` providers.
|
||
// A variant change alters the embedding dimension, which the
|
||
// indexer's dims-mismatch guard detects -- stale vectors of the
|
||
// old width are discarded and the corpus is re-embedded.
|
||
Variant string `mapstructure:"variant" yaml:"variant,omitempty"`
|
||
}
|
||
|
||
// EmbeddingEnabledOrDefault resolves the tri-state Enabled flag against
|
||
// the default-on policy: an unset flag means semantic search is ON.
|
||
func (e EmbeddingConfig) EmbeddingEnabledOrDefault() bool {
|
||
if e.Enabled == nil {
|
||
return true
|
||
}
|
||
return *e.Enabled
|
||
}
|
||
|
||
// ExternalCallSynthesisEnabledOrDefault resolves the tri-state
|
||
// SynthesizeExternalCalls flag against the default-on policy: an unset
|
||
// flag (key absent) means external-package call qualification is ON, so
|
||
// every external call gets a stable cross-repo identity node by default.
|
||
// Default-on is affordable because the synthesis is incrementalised — a
|
||
// single-file reindex re-materialises only that file's external terminals
|
||
// (SynthesizeExternalCallsForFiles) instead of recomputing the whole
|
||
// graph — and the disk backend selects candidate edges through a pushdown
|
||
// (graph.ExternalCallCandidates) served by a partial index. Opt out
|
||
// per-repo with the key set to false or GORTEX_SYNTH_EXTERNAL_CALLS=0.
|
||
func (i IndexConfig) ExternalCallSynthesisEnabledOrDefault() bool {
|
||
if i.SynthesizeExternalCalls == nil {
|
||
return true
|
||
}
|
||
return *i.SynthesizeExternalCalls
|
||
}
|
||
|
||
// SpeculativeDispatchEnabledOrDefault resolves the tri-state
|
||
// SynthesizeSpeculativeDispatch flag against a default-OFF policy: an unset
|
||
// flag means speculative dynamic-dispatch synthesis is disabled (the edges are
|
||
// heuristic fan-outs, opt-in only). Enable per-repo with the key set to true
|
||
// or GORTEX_SYNTH_SPECULATIVE=1.
|
||
func (i IndexConfig) SpeculativeDispatchEnabledOrDefault() bool {
|
||
if i.SynthesizeSpeculativeDispatch == nil {
|
||
return false
|
||
}
|
||
return *i.SynthesizeSpeculativeDispatch
|
||
}
|
||
|
||
// ScopedGlobalPassesEnabledOrDefault resolves the tri-state ScopedGlobalPasses
|
||
// flag against a default-ON policy.
|
||
func (i IndexConfig) ScopedGlobalPassesEnabledOrDefault() bool {
|
||
if i.ScopedGlobalPasses == nil {
|
||
return true
|
||
}
|
||
return *i.ScopedGlobalPasses
|
||
}
|
||
|
||
// EmbeddingProviderOrDefault returns the configured provider name,
|
||
// falling back to `static` (the zero-download default) when unset.
|
||
func (e EmbeddingConfig) EmbeddingProviderOrDefault() string {
|
||
if e.Provider == "" {
|
||
return "static"
|
||
}
|
||
return e.Provider
|
||
}
|
||
|
||
type MCPConfig struct {
|
||
Transport string `mapstructure:"transport" yaml:"transport,omitempty"`
|
||
Port int `mapstructure:"port" yaml:"port,omitempty"`
|
||
Tools MCPToolsConfig `mapstructure:"tools" yaml:"tools,omitempty"`
|
||
// RedactConfigSecrets governs whether the content-serving read sinks
|
||
// (read_file / get_symbol_source / smart_context) withhold secret-shaped
|
||
// values from config / data-leaf files. A nil pointer means the default
|
||
// (redaction ON); set it to false to serve config-leaf values verbatim.
|
||
RedactConfigSecrets *bool `mapstructure:"redact_config_secrets" yaml:"redact_config_secrets,omitempty"`
|
||
// SmartContext governs the optional in-pack enrichment sections
|
||
// smart_context attaches to its pack. Every section is off by default.
|
||
SmartContext SmartContextConfig `mapstructure:"smart_context" yaml:"smart_context,omitempty"`
|
||
}
|
||
|
||
// RedactConfigSecretsEnabled reports whether config-leaf secret redaction is
|
||
// active for this MCP config. Redaction is on by default (a nil pointer), so an
|
||
// agent reading a populated .env / secrets.yaml gets the keys with their values
|
||
// withheld unless the caller opts out per call or sets this field false.
|
||
func (c MCPConfig) RedactConfigSecretsEnabled() bool {
|
||
return c.RedactConfigSecrets == nil || *c.RedactConfigSecrets
|
||
}
|
||
|
||
// MCPToolsConfig selects which MCP tools the server publishes. Preset is
|
||
// one of core (default) / full / readonly / edit / nav; Allow / Deny are
|
||
// per-tool deltas layered on the preset; Mode is "hide" (remove
|
||
// non-allowed tools from tools/list and hard-block calls) or "defer"
|
||
// (hide from the cold tools/list but keep reachable via tools_search).
|
||
// The default is core/defer — a lean, curated dev-cycle surface ships
|
||
// eagerly and the rest stay one tools_search away — so a cold session
|
||
// pays for ~34 tool schemas instead of the full ~180. Opt back into the
|
||
// whole surface with preset "full" (or GORTEX_TOOLS=full).
|
||
// GORTEX_TOOLS / GORTEX_TOOLS_MODE override these at runtime.
|
||
type MCPToolsConfig struct {
|
||
Preset string `mapstructure:"preset" yaml:"preset,omitempty"`
|
||
Mode string `mapstructure:"mode" yaml:"mode,omitempty"`
|
||
Allow []string `mapstructure:"allow" yaml:"allow,omitempty"`
|
||
Deny []string `mapstructure:"deny" yaml:"deny,omitempty"`
|
||
}
|
||
|
||
// defaultMaxParseBytesInFlight caps concurrent raw source bytes in
|
||
// extraction. 512 MiB keeps normal source indexing fully parallel (code
|
||
// files are tiny) while bounding peak memory when a repo carries large
|
||
// content assets (PDFs, office documents, datasets).
|
||
const defaultMaxParseBytesInFlight = 512 << 20
|
||
|
||
// defaultMaxDocumentBytes is the built-in per-file cap for document
|
||
// assets (PDF / pptx / xlsx / text). 10 MiB keeps normal-size documents
|
||
// searchable while dropping the few huge decks / spreadsheets that
|
||
// dominate a content repo's admitted bytes and blow up parse memory.
|
||
const defaultMaxDocumentBytes = 10 << 20
|
||
|
||
// defaultMaxDataBytes is the built-in per-file cap applied to data assets
|
||
// only when index.content.index_data opts them in — a backstop against a
|
||
// multi-GB shard. Matches the data extractor's stream-hash ceiling.
|
||
const defaultMaxDataBytes = 64 << 20
|
||
|
||
// Default returns a Config with sensible defaults.
|
||
//
|
||
// Exclude is intentionally empty here — the builtin baseline lives in
|
||
// excludes.Builtin and is layered in by ConfigManager.EffectiveExclude.
|
||
// Callers that need the full effective list should go through the
|
||
// ConfigManager, not Default().
|
||
func Default() *Config {
|
||
return &Config{
|
||
Index: IndexConfig{
|
||
Workers: runtime.NumCPU(),
|
||
MaxParseBytesInFlight: defaultMaxParseBytesInFlight,
|
||
// MaxFileSize: 0 = no cap. Opt-in knob for users who want
|
||
// to skip large generated/minified files.
|
||
// Prose indexing is on by default; the ConfigManager
|
||
// re-derives this from search.index_prose.
|
||
IndexProse: true,
|
||
// Corpus-admission defaults: cap document assets at 10 MiB
|
||
// and skip binary/vector data assets unless opted in (#120).
|
||
Content: ContentAdmissionConfig{
|
||
MaxDocumentBytes: defaultMaxDocumentBytes,
|
||
IndexData: false,
|
||
MaxDataBytes: defaultMaxDataBytes,
|
||
},
|
||
},
|
||
Watch: WatchConfig{
|
||
Enabled: false,
|
||
Paths: []string{"."},
|
||
DebounceMs: 150,
|
||
},
|
||
Query: QueryConfig{
|
||
DefaultDepth: 3,
|
||
MaxDepth: 10,
|
||
},
|
||
Scope: ScopeConfig{
|
||
IntentDefaults: true,
|
||
},
|
||
MCP: MCPConfig{
|
||
Transport: "stdio",
|
||
Port: 8765,
|
||
// Default tool surface: a curated dev-cycle "core" preset in
|
||
// defer mode — the lean cold tools/list is the workhorse set,
|
||
// the rest stay reachable on demand via tools_search. Opt into
|
||
// the full eager surface with preset "full" / GORTEX_TOOLS=full.
|
||
Tools: MCPToolsConfig{
|
||
Preset: "core",
|
||
Mode: "defer",
|
||
},
|
||
},
|
||
Multi: MultiRepoConfig{
|
||
AutoDetect: false,
|
||
},
|
||
Semantic: SemanticConfig{
|
||
Enabled: true,
|
||
TimeoutSeconds: 120,
|
||
EnrichOnWatch: false,
|
||
WatchDebounceMs: 500,
|
||
SkipEmbed: DefaultSkipEmbed(),
|
||
SkipSearch: DefaultSkipSearch(),
|
||
},
|
||
}
|
||
}
|
||
|
||
// Load reads config from file, environment, and returns a merged Config.
|
||
// configPath may be empty; in that case only default locations are searched.
|
||
//
|
||
// Legacy-shape handling: previously the `workspace:` key held a struct
|
||
// (`workspace: { auto_detect: true }`). The new schema
|
||
// reclaims `workspace:` as a scalar slug. Existing configs are migrated
|
||
// in place — `workspace.auto_detect` lifts into `multi.auto_detect`,
|
||
// and the loader emits a one-line deprecation note via the returned
|
||
// error chain (callers can choose whether to surface or swallow it).
|
||
func Load(configPath string) (*Config, error) {
|
||
v := viper.New()
|
||
v.SetConfigName(".gortex")
|
||
v.SetConfigType("yaml")
|
||
|
||
if configPath != "" {
|
||
v.SetConfigFile(configPath)
|
||
} else {
|
||
v.AddConfigPath(".")
|
||
v.AddConfigPath(platform.ConfigDir())
|
||
}
|
||
|
||
v.SetEnvPrefix("GORTEX")
|
||
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
|
||
v.AutomaticEnv()
|
||
|
||
cfg := Default()
|
||
|
||
if err := v.ReadInConfig(); err != nil {
|
||
if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
|
||
return nil, err
|
||
}
|
||
// No config file found — use defaults + env.
|
||
}
|
||
|
||
// Migrate legacy `workspace:` mapping shape (held a struct with
|
||
// `auto_detect`) into the new `multi:` block so the v.Unmarshal
|
||
// below decodes the new schema cleanly. We do the migration on the
|
||
// viper key map so env-var overrides and viper's own merge logic
|
||
// stay consistent.
|
||
migrateLegacyWorkspaceKey(v)
|
||
|
||
if err := v.Unmarshal(cfg); err != nil {
|
||
return nil, err
|
||
}
|
||
cfg.Scope = cfg.Scope.MergeEnv()
|
||
|
||
if err := cfg.validateWorkspaceSchema(); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return cfg, nil
|
||
}
|
||
|
||
// migrateLegacyWorkspaceKey rewrites `workspace.auto_detect` → `multi.auto_detect`
|
||
// in the viper key store before unmarshal, so a `.gortex.yaml` written
|
||
// against the legacy schema still produces a working Config without the
|
||
// caller seeing a parse error. The migration is silent — there's no
|
||
// global logger here — but the audit step (`gortex audit_agent_config`,
|
||
// reserved for a follow-up) can flag the deprecated key.
|
||
//
|
||
// Only the documented legacy field is migrated. Any other map under
|
||
// `workspace:` is rejected by `validateWorkspaceSchema` so unknown
|
||
// shapes don't get silently ignored.
|
||
func migrateLegacyWorkspaceKey(v *viper.Viper) {
|
||
raw := v.Get("workspace")
|
||
if raw == nil {
|
||
return
|
||
}
|
||
switch t := raw.(type) {
|
||
case string:
|
||
// Already in new shape; nothing to do.
|
||
case map[string]interface{}:
|
||
if ad, ok := t["auto_detect"]; ok {
|
||
// Move to the new home unless `multi.auto_detect`
|
||
// is already set explicitly (caller wins).
|
||
if v.Get("multi.auto_detect") == nil {
|
||
v.Set("multi.auto_detect", ad)
|
||
}
|
||
}
|
||
// The old shape never carried a workspace identity slug,
|
||
// so we clear the polymorphic key so v.Unmarshal doesn't
|
||
// fail trying to coerce a map into a string.
|
||
v.Set("workspace", "")
|
||
case map[interface{}]interface{}:
|
||
// yaml.v2 / older path — same semantics.
|
||
if ad, ok := t["auto_detect"]; ok {
|
||
if v.Get("multi.auto_detect") == nil {
|
||
v.Set("multi.auto_detect", ad)
|
||
}
|
||
}
|
||
v.Set("workspace", "")
|
||
default:
|
||
// Unrecognised shape; downstream coercion will surface
|
||
// a precise error rather than us silently dropping it.
|
||
}
|
||
}
|
||
|
||
// validateWorkspaceSchema enforces the defaults / boundaries that
|
||
// can't be expressed via struct tags alone:
|
||
//
|
||
// - `Project` and `Projects[]` are mutually exclusive (a repo is
|
||
// either single-project or a monorepo, never both).
|
||
// - Every `CrossWorkspaceDeps[].Mode` must be `read-only`. Iteration 1
|
||
// ships only the read-only mode.
|
||
// - `Workspace` slug, when set, may not be empty after trimming.
|
||
//
|
||
// Errors are concatenated so a malformed file surfaces every problem
|
||
// in one pass rather than one round-trip per fix.
|
||
func (c *Config) validateWorkspaceSchema() error {
|
||
var errs []string
|
||
if c.Project != "" && len(c.Projects) > 0 {
|
||
errs = append(errs, "config: 'project' and 'projects' are mutually exclusive — pick one")
|
||
}
|
||
for _, dep := range c.CrossWorkspaceDeps {
|
||
if dep.Workspace == "" {
|
||
errs = append(errs, "config: cross_workspace_deps[].workspace is required")
|
||
}
|
||
if len(dep.Modules) == 0 {
|
||
errs = append(errs, "config: cross_workspace_deps[\""+dep.Workspace+"\"].modules must be non-empty")
|
||
}
|
||
switch dep.Mode {
|
||
case "", "read-only":
|
||
// Empty defaults to read-only (the only iteration-1 mode).
|
||
default:
|
||
errs = append(errs,
|
||
"config: cross_workspace_deps[\""+dep.Workspace+"\"].mode = "+
|
||
strconv.Quote(dep.Mode)+" is unsupported in iteration 1; only \"read-only\" is allowed")
|
||
}
|
||
}
|
||
// Validate passive-attach blocks on each semantic provider. An
|
||
// empty `connect: {}` (both fields blank) is rejected here so a
|
||
// misconfigured YAML produces a clear error at load time rather
|
||
// than silently spawning the subprocess and surprising the user
|
||
// when the IDE coexistence story fails.
|
||
for _, pc := range c.Semantic.Providers {
|
||
if err := pc.Connect.Validate(); err != nil {
|
||
errs = append(errs, fmt.Sprintf("config: semantic.providers[%q]: %v", pc.Name, err))
|
||
}
|
||
}
|
||
if len(errs) == 0 {
|
||
return nil
|
||
}
|
||
return fmt.Errorf("%s", strings.Join(errs, "; "))
|
||
}
|
||
|
||
// ValidateSemanticConnectForTest exposes the connect-block validation
|
||
// loop for tests that build a Config in memory and want to assert the
|
||
// loader would reject it. Production callers go through Load() which
|
||
// runs the full validateWorkspaceSchema pass; this thin export keeps
|
||
// the test surface small without forcing tests to also satisfy the
|
||
// cross_workspace_deps preconditions.
|
||
func (c *Config) ValidateSemanticConnectForTest() error {
|
||
var errs []string
|
||
for _, pc := range c.Semantic.Providers {
|
||
if err := pc.Connect.Validate(); err != nil {
|
||
errs = append(errs, fmt.Sprintf("config: semantic.providers[%q]: %v", pc.Name, err))
|
||
}
|
||
}
|
||
if len(errs) == 0 {
|
||
return nil
|
||
}
|
||
return fmt.Errorf("%s", strings.Join(errs, "; "))
|
||
}
|