dimitar
012fbf8ac5
Close out the plan with the remaining polish items and a full README.
Shell completions (cmd/gitflow):
- New `completion [bash|zsh|fish|powershell]` command backed by cobra's
generators, wired into the root command
Desktop notifications (internal/notify):
- Send() dispatches to notify-send (Linux) with an osascript fallback
(macOS); Windows is a documented no-op for now; missing notifiers are
silent, never errors
- watch --notify sends a notification listing repositories whose state
changed since the previous frame
Color themes (internal/presenter):
- ThemeMode (dark/light) with ParseTheme; light uses bright ANSI variants
(90-97) that stay legible on light backgrounds; threaded through the
table, compact, and suggestions renderers; new --theme flag validated
and dumped by config
Custom rules (internal/rules):
- Rule{name, field (ahead|behind|stash|changes), op (==,!=,<,<=,>,>=),
value, label} with upfront validation in both Validate and Eval
- Config gains a `rules:` section (yaml/env only, no flag), validated at
load; matches render as a "FLAGS (custom rules)" section via a new
presenter.Flags renderer, shown in scan and watch frames
Docs:
- readme.md fully rewritten: features, install, usage, examples, flag
table, status classes, configuration reference, AI agent behavior and
--ai-execute guardrails, development layout, CI, and future work
- implementation.md gains an Implementation Progress section recording
every phase branch and the deviations from the original plan
Multi-platform:
- Verified cross-compilation for windows/amd64 and darwin/arm64; the
notify package is split behind build tags
Testing:
- rules: validation, operator semantics, Eval ordering, invalid-rule
errors
- presenter: ParseTheme, light-theme bright codes (and absence of
dark-theme codes), Flags rendering (empty = silent, matches render)
- config: rules loading from file, invalid-rule rejection, bad theme and
bad provider rejection
- notify: no-op behaviour when no notifier is installed (skipped when one
is, to avoid firing real notifications)
Verified: go build, go vet, go test -race (10 packages), gofmt clean,
windows/darwin cross-compile, completion generation, rules + light theme
smoke test, watch --notify graceful shutdown (exit 0, no orphans).
105 lines
2.7 KiB
Go
105 lines
2.7 KiB
Go
// Package rules evaluates user-defined threshold rules against a scan
|
|
// result, producing labels for repositories that match (e.g. flag a branch
|
|
// as "stale" when it is 10+ commits behind).
|
|
package rules
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"gitea.oblak.solutions/dimitar/gitFlow/pkg/status"
|
|
)
|
|
|
|
// Rule flags a repository when a numeric field crosses a threshold.
|
|
type Rule struct {
|
|
Name string `yaml:"name"` // descriptive name, for config output
|
|
Field string `yaml:"field"` // ahead, behind, stash, or changes
|
|
Op string `yaml:"op"` // ==, !=, <, <=, >, >=
|
|
Value int `yaml:"value"` // threshold to compare against
|
|
Label string `yaml:"label"` // flag label, e.g. "critical"
|
|
}
|
|
|
|
// Validate checks that the rule can be evaluated.
|
|
func (r Rule) Validate() error {
|
|
switch r.Field {
|
|
case "ahead", "behind", "stash", "changes":
|
|
default:
|
|
return fmt.Errorf("rules: %s: unknown field %q (want ahead, behind, stash, or changes)", r.Name, r.Field)
|
|
}
|
|
switch r.Op {
|
|
case "==", "!=", "<", "<=", ">", ">=":
|
|
default:
|
|
return fmt.Errorf("rules: %s: unknown operator %q (want ==, !=, <, <=, >, >=)", r.Name, r.Op)
|
|
}
|
|
if r.Label == "" {
|
|
return fmt.Errorf("rules: %s: label must not be empty", r.Name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Flag is a rule match on a repository.
|
|
type Flag struct {
|
|
RepoPath string
|
|
Label string
|
|
}
|
|
|
|
// Matches reports whether the rule matches the repository.
|
|
func (r Rule) Matches(repo status.RepoInfo) (bool, error) {
|
|
v, err := fieldValue(r.Field, repo)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
switch r.Op {
|
|
case "==":
|
|
return v == r.Value, nil
|
|
case "!=":
|
|
return v != r.Value, nil
|
|
case "<":
|
|
return v < r.Value, nil
|
|
case "<=":
|
|
return v <= r.Value, nil
|
|
case ">":
|
|
return v > r.Value, nil
|
|
case ">=":
|
|
return v >= r.Value, nil
|
|
}
|
|
return false, fmt.Errorf("rules: %s: unknown operator %q", r.Name, r.Op)
|
|
}
|
|
|
|
// Eval applies the rules to the result and returns every match, in scan
|
|
// order. Rules are validated up front; an invalid rule is an error.
|
|
func Eval(rules []Rule, result status.ScanResult) ([]Flag, error) {
|
|
for _, rule := range rules {
|
|
if err := rule.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
var out []Flag
|
|
for _, rule := range rules {
|
|
for _, repo := range result.Repos {
|
|
ok, err := rule.Matches(repo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if ok {
|
|
out = append(out, Flag{RepoPath: repo.Path, Label: rule.Label})
|
|
}
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// fieldValue extracts the numeric field a rule compares against.
|
|
func fieldValue(field string, repo status.RepoInfo) (int, error) {
|
|
switch field {
|
|
case "ahead":
|
|
return repo.AheadBy, nil
|
|
case "behind":
|
|
return repo.BehindBy, nil
|
|
case "stash":
|
|
return repo.StashCount, nil
|
|
case "changes":
|
|
return repo.FileCount(), nil
|
|
}
|
|
return 0, fmt.Errorf("rules: unknown field %q", field)
|
|
}
|