mathiasandClaude Sonnet 5.5
8988c291ca
Removes the LLM classifier, the substring 'BM25' scorer, the agreement gate, the backtest and the old migrate/wingmigrate tooling: measured at 2 of 55 pages placed (#208), and the migration was built for the per-wing facts layout this branch replaces. wing now holds the decision types, the Router and KnownWings. INGEST_WING_ROUTING=1 builds the Router (default wing INGEST_DEFAULT_WING=web-clip, client pattern from INGEST_CLIENT_BLOCK or CLAUDE_INGEST_CLIENT_BLOCK); a bad default or pattern is fatal at startup. Watcher tests rewritten for the Router, including a deliberate subfolder into any existing wing, typo'd folders parked, forged-key and edit-while-placing cases. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
85 lines
3.2 KiB
Go
85 lines
3.2 KiB
Go
package wing
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
)
|
|
|
|
// Router places a note with rules only, no model (hyperguild#208):
|
|
//
|
|
// 1. A subfolder or frontmatter `wing:` is the owner's deliberate choice. It
|
|
// must name a plain, EXISTING wing (a typo never creates one) and then it
|
|
// places, whatever the wing is: extraction runs on the local model, and it
|
|
// is the owner who dropped the note there. Two signals that disagree park.
|
|
// 2. With no signal, a note whose text matches ClientBlock is parked; any
|
|
// other note goes to Default, the one wing that is created on first use.
|
|
//
|
|
// Wings are read from disk on every decision, so a wing created while the
|
|
// server runs is usable at once.
|
|
type Router struct {
|
|
BrainDir string
|
|
Default string
|
|
ClientBlock *regexp.Regexp // nil = no content check
|
|
}
|
|
|
|
// Resolve implements Placer. It never returns an error: anything it cannot
|
|
// decide safely is an Exception with the reason spelled out.
|
|
func (r Router) Resolve(_ context.Context, n Note) Decision {
|
|
dir, fm := norm(n.Dir), norm(n.FrontmatterWing)
|
|
switch {
|
|
case dir != "" && fm != "" && dir != fm:
|
|
return exception("", 0, fmt.Sprintf("subfolder %q and frontmatter wing %q disagree", dir, fm))
|
|
case dir != "":
|
|
return r.explicit(dir, "subfolder")
|
|
case fm != "":
|
|
return r.explicit(fm, "frontmatter")
|
|
}
|
|
if r.ClientBlock != nil && r.ClientBlock.MatchString(n.Text) {
|
|
return exception("", 0, "text matches the client-content marker; not defaulted into a shared wing")
|
|
}
|
|
if r.Default == "" || !plainWingName(r.Default) {
|
|
return exception("", 0, "no valid default wing configured")
|
|
}
|
|
return Decision{Wing: r.Default, Source: Default, Confidence: 1, Reason: "no wing named; default wing"}
|
|
}
|
|
|
|
func (r Router) explicit(w, via string) Decision {
|
|
if !plainWingName(w) {
|
|
return exception("", 0, fmt.Sprintf("%s names %q, which is not a plain wing name", via, w))
|
|
}
|
|
if w == r.Default && plainWingName(w) {
|
|
return Decision{Wing: w, Source: Explicit, Confidence: 1, Reason: "named by " + via}
|
|
}
|
|
known, err := KnownWings(r.BrainDir)
|
|
if err != nil {
|
|
return exception(w, 0, fmt.Sprintf("cannot list wings: %v", err))
|
|
}
|
|
if !slices.Contains(known, w) {
|
|
return exception(w, 0, fmt.Sprintf("%s names %q: not an existing wing (new wings are never created from a folder name)", via, strings.TrimSpace(w)))
|
|
}
|
|
return Decision{Wing: w, Source: Explicit, Confidence: 1, Reason: "named by " + via}
|
|
}
|
|
|
|
// NewRouter builds the production Router. defaultWing must be a plain wing
|
|
// name; clientPattern, when set, is a case-insensitive regexp over note text
|
|
// whose match parks an unsignalled note instead of filing it. Both fail at
|
|
// startup rather than later: a client filter that silently does nothing is
|
|
// worse than none.
|
|
func NewRouter(brainDir, defaultWing, clientPattern string) (Router, error) {
|
|
if defaultWing == "" || !plainWingName(defaultWing) {
|
|
return Router{}, fmt.Errorf("default wing %q is not a plain wing name", defaultWing)
|
|
}
|
|
r := Router{BrainDir: brainDir, Default: defaultWing}
|
|
if clientPattern != "" {
|
|
re, err := regexp.Compile("(?i)" + clientPattern)
|
|
if err != nil {
|
|
return Router{}, fmt.Errorf("client-content pattern: %w", err)
|
|
}
|
|
r.ClientBlock = re
|
|
}
|
|
return r, nil
|
|
}
|