feat: add the kettle CLI, replacing the plugin's Python scripts
The plugin resolved its issue store from `__file__`, which put it inside a versioned plugin cache: issues written from one project were invisible from the next, and `origin: local` files — the only copy of that work by definition — were stranded a version bump at a time. The walk that answers "which directory is the project" was written three times over, and in a linked worktree the three disagreed. Both are runtime failures rather than logic ones, so the fix is a compiled binary: one walk, imported rather than re-derived, and a layering rule the build graph enforces instead of a grep. Seven packages, knowledge flowing one way. `project` answers which directory is the project and depends on nothing. `issue` is the domain — format, taxonomy, validation, checkboxes, dependency graph, the store, eviction — offline, with no tracker in it. `wire` holds the protocol shapes. `gitea` is the transport, `mapping` the bridge, `config` the credentials, `cmd` the command tree. Four tests hold the boundaries, each failing on a real mistake rather than a naming convention. The marker moves to `.kettle/` and the login pin moves out of the harness's settings file into `.kettle/config.yaml`, which pins a login by NAME; the tokens live in one file per machine, mode 0600, outside every working tree. That retires the PreToolUse guard hook entirely — the binary holds its own credentials, so a command running under a login nobody chose is not expressible rather than caught. `kettle init` migrates an older `tmp/issues` or `.tea/issues` store in, as a move: a store left behind at an old path is one somebody edits by accident months later. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
naudachu
@@ -0,0 +1,155 @@
|
||||
package issue
|
||||
|
||||
import (
|
||||
"os"
|
||||
"sort"
|
||||
)
|
||||
|
||||
// Closed issues leave the store. The store is a working set, not an archive.
|
||||
//
|
||||
// WHAT IS EVICTED, and it is two conditions, both read off the file:
|
||||
//
|
||||
// state: closed the work is done
|
||||
// origin: <tracker> the work is somewhere else too
|
||||
//
|
||||
// THE SECOND CONDITION IS THE WHOLE SAFETY ARGUMENT. `origin: local` means this
|
||||
// file IS the issue — there is no other copy and deleting it deletes the work.
|
||||
// It is therefore never evicted, in any state, not even when named explicitly:
|
||||
// a closed local issue is reported and kept. The only files that go are ones
|
||||
// whose own metadata says the work can be fetched back, which is the same trade
|
||||
// a push makes when it drops a file the tracker has just confirmed.
|
||||
//
|
||||
// That parallel is exact except for where the confirmation comes from. Push has
|
||||
// to ask the tracker, because it is the tracker that just changed. Eviction asks
|
||||
// the file, because state and origin are domain fields and the answer is already
|
||||
// in the store — which is why this lives in the domain and needs no network, no
|
||||
// login, and no tracker. The sync layer's variant refreshes state from the
|
||||
// tracker first and then calls Evict, so there is exactly one implementation of
|
||||
// "what may be evicted" and it is this one.
|
||||
//
|
||||
// NOT A ONE-OFF MIGRATION. A pull by number fetches an issue in any state — a
|
||||
// number is an address, not a query — so a closed issue pulled after an eviction
|
||||
// lands on disk again. That is the tracker being asked a direct question, not a
|
||||
// regression; evict it again when you are done with it.
|
||||
//
|
||||
// `.remote.json` is deliberately NOT pruned. It is the local number -> slug
|
||||
// ledger, its entries outlive the files they name, and an evicted issue is in
|
||||
// exactly that state. INDEX.md is rebuilt, because it IS a view of the
|
||||
// directory.
|
||||
|
||||
const closed = "closed"
|
||||
|
||||
// LocalReason is printed whether or not the issue was named, because "this
|
||||
// closed thing is still here" needs an answer every time.
|
||||
const LocalReason = "origin: " + Local + " — this file IS the issue"
|
||||
|
||||
// Evicted is one issue that left the store, with every file that went with it.
|
||||
type Evicted struct {
|
||||
ID string
|
||||
Paths []string
|
||||
}
|
||||
|
||||
// Kept is one issue that was considered and stayed, with the reason.
|
||||
type Kept struct {
|
||||
ID string
|
||||
Why string
|
||||
Open bool // true when it is simply not closed yet — the normal case
|
||||
}
|
||||
|
||||
// EvictReport is what a run did, or would have done.
|
||||
type EvictReport struct {
|
||||
Evicted []Evicted
|
||||
Kept []Kept
|
||||
DryRun bool
|
||||
IndexPath string
|
||||
IndexCount int
|
||||
}
|
||||
|
||||
// Classify splits the store into what may be evicted, what is protected, and
|
||||
// what is still open.
|
||||
//
|
||||
// Pure — it reads the loaded issues and decides; nothing here touches disk.
|
||||
// ids restricts the question to those issues; empty considers the whole store.
|
||||
// A protected issue is returned as such even when it was named explicitly:
|
||||
// naming a file does not make deleting it safe.
|
||||
func Classify(issues map[string]*Issue, ids []string) (evict, protected, stillOpen []string) {
|
||||
chosen := ids
|
||||
if len(chosen) == 0 {
|
||||
for id := range issues {
|
||||
chosen = append(chosen, id)
|
||||
}
|
||||
sort.Strings(chosen)
|
||||
}
|
||||
for _, id := range chosen {
|
||||
i, ok := issues[id]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
switch {
|
||||
case i.State != closed:
|
||||
stillOpen = append(stillOpen, id)
|
||||
case i.IsLocal():
|
||||
protected = append(protected, id)
|
||||
default:
|
||||
evict = append(evict, id)
|
||||
}
|
||||
}
|
||||
return evict, protected, stillOpen
|
||||
}
|
||||
|
||||
// Remove deletes everything the store holds under one slug and returns the
|
||||
// paths that went.
|
||||
//
|
||||
// Deliberately dumb: it takes an id, not a decision. Whether an issue may go is
|
||||
// settled by Classify before this is reached, so the dangerous half of the
|
||||
// operation has no branches in it at all.
|
||||
func Remove(root, id string) ([]string, error) {
|
||||
var gone []string
|
||||
for _, p := range SlugFiles(root, id) {
|
||||
if err := os.Remove(p); err != nil {
|
||||
return gone, err
|
||||
}
|
||||
gone = append(gone, p)
|
||||
}
|
||||
return gone, nil
|
||||
}
|
||||
|
||||
// Evict classifies, removes, and rebuilds the index. The one implementation,
|
||||
// called both by the offline command and by the sync layer — which does nothing
|
||||
// to this decision except hand over issues whose state it has just refreshed
|
||||
// from the tracker.
|
||||
func Evict(root string, issues map[string]*Issue, ids []string, dryRun bool) (*EvictReport, error) {
|
||||
evict, protected, stillOpen := Classify(issues, ids)
|
||||
rep := &EvictReport{DryRun: dryRun}
|
||||
|
||||
for _, id := range evict {
|
||||
var paths []string
|
||||
if dryRun {
|
||||
paths = SlugFiles(root, id)
|
||||
} else {
|
||||
var err error
|
||||
if paths, err = Remove(root, id); err != nil {
|
||||
return rep, err
|
||||
}
|
||||
}
|
||||
rep.Evicted = append(rep.Evicted, Evicted{ID: id, Paths: paths})
|
||||
}
|
||||
for _, id := range protected {
|
||||
rep.Kept = append(rep.Kept, Kept{ID: id, Why: LocalReason})
|
||||
}
|
||||
for _, id := range stillOpen {
|
||||
rep.Kept = append(rep.Kept, Kept{ID: id, Why: "state: " + issues[id].State, Open: true})
|
||||
}
|
||||
|
||||
// Only when something actually went: the index is a view of the directory,
|
||||
// and rewriting it after a run that changed nothing is a write nobody asked
|
||||
// for.
|
||||
if !dryRun && len(rep.Evicted) > 0 {
|
||||
path, n, err := BuildIndex(root)
|
||||
if err != nil {
|
||||
return rep, err
|
||||
}
|
||||
rep.IndexPath, rep.IndexCount = path, n
|
||||
}
|
||||
return rep, nil
|
||||
}
|
||||
Reference in New Issue
Block a user