feat(legacymove): clear the retired wiki/sources layout with an archive and a rollback (#209)
Videos and articles move to the default wing (wing/hall stamped, body and links byte-preserved); auto-tunnel review logs are deleted; notes, projects and untyped pages stay. Plan is read-only; Apply archives every page it touches to archive/wing-migration-<date>/ (outside raw/) before changing anything, creates destinations O_EXCL and removes sources only after; Rollback restores byte for byte. concepts/ and entities/ are the shared layer and are untouched. Dry run against the live brain: 16 move, 24 delete, 15 left. Mutation-checked: junk guard, type filter, slug collision, no-overwrite, archive-before-change, action gate. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5.5
@@ -0,0 +1,254 @@
|
||||
// Package legacymove clears wiki/sources/ of the retired layout (hyperguild
|
||||
// #209). It does the one thing that is safe to do mechanically: video and
|
||||
// article source pages move to the default wing, and the auto-tunnel review
|
||||
// logs that were once ingested as "sources" are deleted. Notes, projects and
|
||||
// untyped pages stay where they are, and wiki/concepts and wiki/entities are
|
||||
// not touched at all (they are the shared layer).
|
||||
//
|
||||
// Plan only reads. Apply copies every page it touches into
|
||||
// archive/wing-migration-<date>/ first, so Rollback can restore the brain
|
||||
// byte for byte. The archive is outside raw/, so the watcher never ingests it.
|
||||
package legacymove
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"path"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
|
||||
"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
|
||||
"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
|
||||
)
|
||||
|
||||
// Action is what the plan does with one page.
|
||||
type Action string
|
||||
|
||||
const (
|
||||
Move Action = "move"
|
||||
Delete Action = "delete"
|
||||
Skip Action = "skip"
|
||||
)
|
||||
|
||||
// Item is one planned operation.
|
||||
type Item struct {
|
||||
From string
|
||||
To string // Move only
|
||||
Slug string
|
||||
Action Action
|
||||
Wing string // Move only
|
||||
Reason string
|
||||
}
|
||||
|
||||
const legacyDir = "wiki/sources"
|
||||
|
||||
// Plan reads the retired source dir and decides. It writes nothing.
|
||||
func Plan(brainDir, wing string) ([]Item, error) {
|
||||
if wing == "" || brain.Sanitise(wing) != wing {
|
||||
return nil, fmt.Errorf("wing %q is not a plain wing name", wing)
|
||||
}
|
||||
bfs, err := brainfs.Open(brainDir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("open brain: %w", err)
|
||||
}
|
||||
defer func() { _ = bfs.Close() }()
|
||||
names, err := bfs.ReadDirRegular(legacyDir)
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return nil, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read %s: %w", legacyDir, err)
|
||||
}
|
||||
var items []Item
|
||||
for _, name := range names {
|
||||
if !strings.HasSuffix(name, ".md") || name == "_index.md" {
|
||||
continue
|
||||
}
|
||||
from := legacyDir + "/" + name
|
||||
slug := strings.TrimSuffix(name, ".md")
|
||||
it := Item{From: from, Slug: slug}
|
||||
if strings.HasPrefix(name, "tunnel-candidates-") {
|
||||
it.Action, it.Reason = Delete, "auto-tunnel review log ingested as a source; not a source"
|
||||
items = append(items, it)
|
||||
continue
|
||||
}
|
||||
content, err := bfs.ReadRegular(from)
|
||||
if err != nil {
|
||||
it.Action, it.Reason = Skip, fmt.Sprintf("unreadable: %v", err)
|
||||
items = append(items, it)
|
||||
continue
|
||||
}
|
||||
switch typ := frontmatterValue(string(content), "type"); typ {
|
||||
case "video", "article":
|
||||
to := "wiki/" + wing + "/sources/" + name
|
||||
it.Action, it.To, it.Wing = Move, to, wing
|
||||
existing, ferr := wiki.FindSlugs(brainDir, slug)
|
||||
if ferr != nil {
|
||||
it.Action, it.To, it.Wing, it.Reason = Skip, "", "", fmt.Sprintf("cannot check slug: %v", ferr)
|
||||
}
|
||||
for _, p := range existing {
|
||||
if p != from {
|
||||
it.Action, it.To, it.Wing, it.Reason = Skip, "", "", fmt.Sprintf("slug %q already used by %s", slug, p)
|
||||
break
|
||||
}
|
||||
}
|
||||
default:
|
||||
it.Action, it.Reason = Skip, fmt.Sprintf("type %q: left in place", typ)
|
||||
}
|
||||
items = append(items, it)
|
||||
}
|
||||
sort.SliceStable(items, func(i, j int) bool { return items[i].From < items[j].From })
|
||||
return items, nil
|
||||
}
|
||||
|
||||
// Result reports what Apply did and where the archive is (brain-relative).
|
||||
type Result struct {
|
||||
Moved, Deleted int
|
||||
ArchiveDir string
|
||||
}
|
||||
|
||||
type manifest struct {
|
||||
Moves []moveRec `json:"moves"`
|
||||
Deletes []string `json:"deletes"`
|
||||
}
|
||||
|
||||
type moveRec struct {
|
||||
From string `json:"from"`
|
||||
To string `json:"to"`
|
||||
}
|
||||
|
||||
// Apply performs the Move and Delete items, one at a time, stopping at the
|
||||
// first failure. Each original is archived before anything changes; a move
|
||||
// writes its destination with O_EXCL before the source is removed, so a failure
|
||||
// never loses a page. The manifest is rewritten after every step so a partial
|
||||
// run can still be rolled back.
|
||||
func Apply(brainDir string, items []Item, now time.Time) (Result, error) {
|
||||
bfs, err := brainfs.Open(brainDir)
|
||||
if err != nil {
|
||||
return Result{}, fmt.Errorf("open brain: %w", err)
|
||||
}
|
||||
defer func() { _ = bfs.Close() }()
|
||||
|
||||
res := Result{ArchiveDir: "archive/wing-migration-" + now.UTC().Format("2006-01-02")}
|
||||
var man manifest
|
||||
save := func() error {
|
||||
b, err := json.MarshalIndent(man, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return bfs.PutRegular(res.ArchiveDir+"/manifest.json", b)
|
||||
}
|
||||
for _, it := range items {
|
||||
if it.Action != Move && it.Action != Delete {
|
||||
continue
|
||||
}
|
||||
content, err := bfs.ReadRegular(it.From)
|
||||
if err != nil {
|
||||
return res, fmt.Errorf("read %s: %w", it.From, err)
|
||||
}
|
||||
if err := bfs.PutRegular(res.ArchiveDir+"/originals/"+path.Base(it.From), content); err != nil {
|
||||
return res, fmt.Errorf("archive %s: %w", it.From, err)
|
||||
}
|
||||
switch it.Action {
|
||||
case Move:
|
||||
if err := bfs.CreateRegular(it.To, []byte(stamp(string(content), it.Wing))); err != nil {
|
||||
return res, fmt.Errorf("write %s: %w", it.To, err)
|
||||
}
|
||||
man.Moves = append(man.Moves, moveRec{From: it.From, To: it.To})
|
||||
res.Moved++
|
||||
case Delete:
|
||||
man.Deletes = append(man.Deletes, it.From)
|
||||
res.Deleted++
|
||||
}
|
||||
if err := save(); err != nil {
|
||||
return res, fmt.Errorf("write manifest: %w", err)
|
||||
}
|
||||
if err := bfs.Remove(it.From); err != nil {
|
||||
return res, fmt.Errorf("handled %s but removing it failed: %w", it.From, err)
|
||||
}
|
||||
}
|
||||
for w := range wingsOf(items) {
|
||||
_ = brain.BuildWingIndex(brainDir, w) // best-effort upkeep; the pages are already moved
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
func wingsOf(items []Item) map[string]bool {
|
||||
out := map[string]bool{}
|
||||
for _, it := range items {
|
||||
if it.Action == Move {
|
||||
out[it.Wing] = true
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Rollback restores every page named in the archive's manifest from its
|
||||
// archived original and removes the moved copies. It refuses to overwrite a
|
||||
// page that already exists at the original location.
|
||||
func Rollback(brainDir, archiveDir string) error {
|
||||
bfs, err := brainfs.Open(brainDir)
|
||||
if err != nil {
|
||||
return fmt.Errorf("open brain: %w", err)
|
||||
}
|
||||
defer func() { _ = bfs.Close() }()
|
||||
raw, err := bfs.ReadRegular(archiveDir + "/manifest.json")
|
||||
if err != nil {
|
||||
return fmt.Errorf("read manifest: %w", err)
|
||||
}
|
||||
var man manifest
|
||||
if err := json.Unmarshal(raw, &man); err != nil {
|
||||
return fmt.Errorf("parse manifest: %w", err)
|
||||
}
|
||||
restore := func(from string) error {
|
||||
orig, err := bfs.ReadRegular(archiveDir + "/originals/" + path.Base(from))
|
||||
if err != nil {
|
||||
return fmt.Errorf("read archived %s: %w", from, err)
|
||||
}
|
||||
if err := bfs.CreateRegular(from, orig); err != nil {
|
||||
return fmt.Errorf("restore %s: %w", from, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
for _, m := range man.Moves {
|
||||
if err := restore(m.From); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bfs.Remove(m.To); err != nil {
|
||||
return fmt.Errorf("remove moved copy %s: %w", m.To, err)
|
||||
}
|
||||
}
|
||||
for _, d := range man.Deletes {
|
||||
if err := restore(d); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// stamp inserts wing/hall after the opening fence, leaving every other byte
|
||||
// alone. A page without frontmatter gets a block.
|
||||
func stamp(content, wing string) string {
|
||||
extra := "wing: " + wing + "\nhall: sources\n"
|
||||
if strings.HasPrefix(content, "---\n") {
|
||||
return "---\n" + extra + content[4:]
|
||||
}
|
||||
return "---\n" + extra + "---\n" + content
|
||||
}
|
||||
|
||||
func frontmatterValue(content, key string) string {
|
||||
if !strings.HasPrefix(content, "---\n") {
|
||||
return ""
|
||||
}
|
||||
block, _, _ := strings.Cut(content[4:], "\n---")
|
||||
for _, line := range strings.Split(block, "\n") {
|
||||
if k, v, ok := strings.Cut(line, ":"); ok && strings.TrimSpace(k) == key {
|
||||
return strings.Trim(strings.TrimSpace(v), `"'`)
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
Reference in New Issue
Block a user