package main import ( "errors" "fmt" "os" "os/exec" "path/filepath" "sort" "strconv" "strings" "time" ) func cmdInit(args parsedArgs) error { root, err := os.Getwd() if err != nil { return err } if args.bools["dry-run"] { files, err := initPreviewFiles(root) if err != nil { return err } result := buildInitResult(root, files, true, false) if wantsJSON(args) { return printJSON(result) } fmt.Printf("Would initialize Haven project with %d base files (%d bytes).\n", result.Files, result.Bytes) fmt.Printf("version %s\n", result.Version) return nil } for _, dir := range []string{"objects", "bases", "goals", "attempts", "overlays", "mounts", "scratch", "envs", "previews", "exports", "commits", "tasks", "plans", "claims", "work-packets"} { if err := os.MkdirAll(filepath.Join(root, hvnDir, dir), 0755); err != nil { return err } } if err := writeMetadataSchema(root); err != nil { return err } if err := ensureHvnignore(root); err != nil { return err } base, err := snapshotBase(root) if err != nil { return err } if err := writeBase(root, base); err != nil { return err } if wantsJSON(args) { return printJSON(buildInitResult(root, base.Files, false, true)) } fmt.Printf("Initialized Haven project with %d base files.\n", len(base.Files)) return nil } func initPreviewFiles(root string) ([]BaseFile, error) { files, err := listFiles(root) if err != nil { return nil, err } for _, file := range files { if file.Path == hvnIgnoreFile { return files, nil } } content := defaultHvnignoreContent() files = append(files, BaseFile{Path: hvnIgnoreFile, Hash: hashBytes(content), Size: int64(len(content)), Mode: 0644}) sort.Slice(files, func(i, j int) bool { return files[i].Path < files[j].Path }) return files, nil } func buildInitResult(root string, files []BaseFile, dryRun, initialized bool) InitResult { totalBytes := int64(0) for _, file := range files { totalBytes += file.Size } largest := append([]BaseFile(nil), files...) sort.Slice(largest, func(i, j int) bool { if largest[i].Size == largest[j].Size { return largest[i].Path < largest[j].Path } return largest[i].Size > largest[j].Size }) if len(largest) > 10 { largest = largest[:10] } sample := []string{} for i, file := range files { if i >= 20 { break } sample = append(sample, file.Path) } dirs := make([]string, 0, len(ignoredDirs)) for dir := range ignoredDirs { dirs = append(dirs, dir) } sort.Strings(dirs) return InitResult{ Root: root, IgnoreFile: filepath.Join(root, hvnIgnoreFile), Files: len(files), Bytes: totalBytes, Version: baseVersion(files), DryRun: dryRun, Initialized: initialized, IgnoredDirs: dirs, SampleFiles: sample, LargestFiles: largest, Diagnostics: onboardingDiagnostics(files), } } func onboardingDiagnostics(files []BaseFile) []Diagnostic { diagnostics := []Diagnostic{} for _, file := range files { lower := strings.ToLower(file.Path) base := strings.ToLower(filepath.Base(file.Path)) switch { case file.Size >= 10*1024*1024: diagnostics = append(diagnostics, Diagnostic{ Severity: "warn", Code: "large-file", Path: file.Path, Message: "large file will be stored in Haven; add an ignore rule if it is generated data", }) case strings.HasSuffix(base, ".log"): diagnostics = append(diagnostics, Diagnostic{ Severity: "warn", Code: "log-file", Path: file.Path, Message: "log file will be tracked; add an ignore rule if it is runtime output", }) case strings.HasSuffix(base, ".db") || strings.HasSuffix(base, ".sqlite") || strings.HasSuffix(base, ".sqlite3"): diagnostics = append(diagnostics, Diagnostic{ Severity: "warn", Code: "local-database", Path: file.Path, Message: "local database will be tracked; add an ignore rule if it is generated state", }) case base == ".env" || strings.HasPrefix(base, ".env.") || strings.Contains(lower, "secret"): diagnostics = append(diagnostics, Diagnostic{ Severity: "warn", Code: "secret-like-file", Path: file.Path, Message: "secret-like file will be tracked; confirm it is a placeholder before initializing", }) } } return diagnostics } func cmdCommit(args parsedArgs) error { root, err := findRoot() if err != nil { return err } message := args.flags["m"] if message == "" { message = args.flags["message"] } if message == "" { return errors.New("usage: hvn commit -m \"message\"") } commit, err := commitBase(root, message) if err != nil { return err } fmt.Printf("%s %s\n", commit.ID, commit.Message) return nil } func commitBase(root, message string) (Commit, error) { parent, err := readHead(root) if err != nil { return Commit{}, err } base, err := snapshotBase(root) if err != nil { return Commit{}, err } if err := writeBase(root, base); err != nil { return Commit{}, err } id := time.Now().UTC().Format("20060102150405") + "-" + short(base.Version) commit := Commit{ID: id, Message: message, BaseVersion: base.Version, Parent: parent, CreatedAt: now(), Files: base.Files} if err := writeJSON(filepath.Join(root, hvnDir, "commits", id+".json"), commit); err != nil { return Commit{}, err } if err := os.WriteFile(filepath.Join(root, hvnDir, "HEAD"), []byte(id+"\n"), 0644); err != nil { return Commit{}, err } return commit, nil } func cmdShow(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn show commit-id") } root, err := findRoot() if err != nil { return err } commit, err := readCommit(root, args.pos[1]) if err != nil { return err } parent := "none" if commit.Parent != "" { parent = commit.Parent } fmt.Printf("commit %s\n", commit.ID) fmt.Printf("created %s\n", commit.CreatedAt) fmt.Printf("base %s\n", commit.BaseVersion) fmt.Printf("parent %s\n", parent) fmt.Printf("message %s\n", commit.Message) fmt.Printf("\nFiles (%d):\n", len(commit.Files)) for _, file := range commit.Files { fmt.Printf(" %s %8d %04o %s\n", short(file.Hash), file.Size, file.Mode, file.Path) } return nil } func cmdRestore(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn restore commit-id") } root, err := findRoot() if err != nil { return err } commit, err := readCommit(root, args.pos[1]) if err != nil { return err } currentBase, err := readBase(root) if err != nil { return err } targetPaths := map[string]bool{} for _, file := range commit.Files { targetPaths[file.Path] = true } for _, file := range currentBase.Files { if targetPaths[file.Path] { continue } target := filepath.Join(root, filepath.FromSlash(file.Path)) if err := os.Remove(target); err != nil && !os.IsNotExist(err) { return err } } for _, file := range commit.Files { data, err := readObject(root, file.Hash) if err != nil { return fmt.Errorf("restore %s: missing object %s: %w", file.Path, file.Hash, err) } target := filepath.Join(root, filepath.FromSlash(file.Path)) if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil { return err } if err := os.WriteFile(target, data, os.FileMode(file.Mode)); err != nil { return err } } base := BaseSnapshot{Version: commit.BaseVersion, CreatedAt: now(), Files: commit.Files} if err := writeBase(root, base); err != nil { return err } if err := os.WriteFile(filepath.Join(root, hvnDir, "HEAD"), []byte(commit.ID+"\n"), 0644); err != nil { return err } fmt.Printf("Restored %s into base snapshot %s.\n", commit.ID, short(commit.BaseVersion)) return nil } func cmdLog(args parsedArgs) error { root, err := findRoot() if err != nil { return err } limit := 20 if raw := args.flags["n"]; raw != "" { parsed, err := strconv.Atoi(raw) if err != nil { return fmt.Errorf("invalid -n value %q", raw) } limit = parsed } commits, err := listCommits(root) if err != nil { return err } if wantsJSON(args) { if limit < len(commits) { commits = commits[:limit] } return printJSON(commits) } if len(commits) == 0 { fmt.Println("No Haven commits.") return nil } for index, commit := range commits { if index >= limit { break } parent := "" if commit.Parent != "" { parent = " parent=" + commit.Parent } fmt.Printf("%s %s\n base=%s%s\n %s\n", commit.ID, commit.CreatedAt, short(commit.BaseVersion), parent, commit.Message) } return nil } func cmdChanges(args ...parsedArgs) error { root, err := findRoot() if err != nil { return err } changes, err := workingChanges(root) if err != nil { return err } if len(args) > 0 && wantsJSON(args[0]) { return printJSON(overlayFilesJSON(changes)) } if len(changes) == 0 { fmt.Println("No base changes since HEAD.") return nil } for _, file := range changes { fmt.Printf("%-8s %s\n", file.Status, file.Path) } return nil } func cmdGoal(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn goal create|list|close|reopen") } root, err := findRoot() if err != nil { return err } switch args.pos[1] { case "create": if len(args.pos) < 3 { return errors.New("usage: hvn goal create \"Title\" [--criteria path]") } title := args.pos[2] id := uniqueID(filepath.Join(root, hvnDir, "goals"), slugify(title)) now := now() goal := Goal{ID: id, Title: title, Status: "open", CreatedAt: now, UpdatedAt: now} if criteria := args.flags["criteria"]; criteria != "" { abs := criteria if !filepath.IsAbs(abs) { abs = filepath.Join(root, criteria) } data, err := os.ReadFile(abs) if err != nil { return err } goal.CriteriaPath = rel(root, abs) goal.CriteriaText = string(data) } if err := writeGoal(root, goal); err != nil { return err } fmt.Println(id) return nil case "list": goals, err := listGoals(root) if err != nil { return err } if wantsJSON(args) { return printJSON(goalsJSON(goals)) } if len(goals) == 0 { fmt.Println("No goals.") return nil } for _, goal := range goals { fmt.Printf("%s [%s] %s\n", goal.ID, goal.Status, goal.Title) } return nil case "close", "reopen": if len(args.pos) < 3 { return fmt.Errorf("usage: hvn goal %s goal-id", args.pos[1]) } goal, err := readGoal(root, args.pos[2]) if err != nil { return err } if args.pos[1] == "close" { goal.Status = "closed" } else { goal.Status = "open" } goal.UpdatedAt = now() if err := writeGoal(root, goal); err != nil { return err } fmt.Printf("%s [%s] %s\n", goal.ID, goal.Status, goal.Title) return nil default: return errors.New("usage: hvn goal create|list|close|reopen") } } func cmdAgent(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn agent spawn|start|sync|clean") } switch args.pos[1] { case "spawn": return cmdAgentSpawn(args, false) case "start": return cmdAgentSpawn(args, true) case "sync": if len(args.pos) < 3 { return errors.New("usage: hvn agent sync attempt-id") } root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[2]) if err != nil { return err } attempt, err = materializeMount(root, attempt) if err != nil { return err } fmt.Println(attempt.MountPath) return nil case "clean": if len(args.pos) < 3 { return errors.New("usage: hvn agent clean attempt-id") } root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[2]) if err != nil { return err } mount := filepath.Join(root, hvnDir, "mounts", attempt.ID) if err := os.RemoveAll(mount); err != nil { return err } attempt.MountPath = "" attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return err } fmt.Printf("Cleaned mount for %s.\n", attempt.ID) return nil default: return errors.New("usage: hvn agent spawn|start|sync|clean") } } type AgentStartResult struct { Attempt Attempt `json:"attempt"` Mount string `json:"mount"` } func agentStartResultsJSON(results []AgentStartResult) []AgentStartResult { if results == nil { return []AgentStartResult{} } return results } func cmdAgentSpawn(args parsedArgs, mountNow bool) error { root, err := findRoot() if err != nil { return err } goalID := args.flags["goal"] if goalID == "" { return errors.New("missing --goal") } if _, err := readGoal(root, goalID); err != nil { return err } count := 1 if raw := args.flags["count"]; raw != "" { if !mountNow { return errors.New("--count is only supported by hvn agent start") } parsed, err := strconv.Atoi(raw) if err != nil || parsed < 1 { return fmt.Errorf("invalid --count value %q", raw) } count = parsed } base, err := readBase(root) if err != nil { return err } if err := writeBase(root, base); err != nil { return err } results := []AgentStartResult{} for i := 0; i < count; i++ { attempt, err := createAgentAttempt(root, goalID, base, args.flags["claim-template"]) if err != nil { return err } if mountNow { attempt, err = materializeMount(root, attempt) if err != nil { return err } results = append(results, AgentStartResult{Attempt: attempt, Mount: attempt.MountPath}) if !wantsJSON(args) { fmt.Printf("%s %s\n", attempt.ID, attempt.MountPath) } continue } fmt.Println(attempt.ID) } if mountNow && wantsJSON(args) { return printJSON(agentStartResultsJSON(results)) } return nil } func createAgentAttempt(root, goalID string, base BaseSnapshot, claimTemplate string) (Attempt, error) { attempts, err := listAttempts(root) if err != nil { return Attempt{}, err } id, err := nextAttemptID(root, attempts) if err != nil { return Attempt{}, err } now := now() attempt := Attempt{ ID: id, GoalID: goalID, Status: "active", BaseVersion: base.Version, DependencyKey: dependencyKey(root), CreatedAt: now, UpdatedAt: now, } if claimTemplate != "" { attempt.Claims = append(attempt.Claims, Claim{Text: claimTemplate, CreatedAt: now}) } overlay := OverlayManifest{AttemptID: id, UpdatedAt: now, Files: []OverlayFile{}} if err := createOverlay(root, overlay); err != nil { if os.IsExist(err) { return Attempt{}, fmt.Errorf("overlay %s already exists; retry spawn", id) } return Attempt{}, err } if err := createAttempt(root, attempt); err != nil { _ = os.Remove(filepath.Join(root, hvnDir, "overlays", id+".json")) return Attempt{}, err } return attempt, nil } func nextAttemptID(root string, attempts []Attempt) (string, error) { used := map[int]bool{} for _, attempt := range attempts { markAttemptID(used, attempt.ID) } paths, err := filepath.Glob(filepath.Join(root, hvnDir, "attempts", "agent-*.json")) if err != nil { return "", err } for _, path := range paths { markAttemptID(used, strings.TrimSuffix(filepath.Base(path), ".json")) } paths, err = filepath.Glob(filepath.Join(root, hvnDir, "overlays", "agent-*.json")) if err != nil { return "", err } for _, path := range paths { markAttemptID(used, strings.TrimSuffix(filepath.Base(path), ".json")) } for i := 1; ; i++ { if !used[i] { return fmt.Sprintf("agent-%d", i), nil } } } func markAttemptID(used map[int]bool, id string) { suffix, ok := strings.CutPrefix(id, "agent-") if !ok { return } n, err := strconv.Atoi(suffix) if err != nil || n < 1 { return } used[n] = true } func createAttempt(root string, attempt Attempt) error { path := attemptPath(root, attempt.ID) if err := writeJSONExclusive(path, attempt); err != nil { if os.IsExist(err) { return fmt.Errorf("attempt %s already exists; retry spawn", attempt.ID) } return err } return nil } func cmdAttempt(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn attempt list|rebase|reject|supersede") } root, err := findRoot() if err != nil { return err } switch args.pos[1] { case "list": attempts, err := listAttempts(root) if err != nil { return err } if wantsJSON(args) { out := []AttemptListJSON{} for _, attempt := range attempts { overlay, _ := readOverlay(root, attempt.ID) out = append(out, AttemptListJSON{ Attempt: attempt, Overlay: overlayJSON(overlay), Env: envStatusFor(root, attempt, overlay), Next: nextAttemptCommand(attempt, len(overlay.Files)), }) } return printJSON(out) } if len(attempts) == 0 { fmt.Println("No attempts.") return nil } for _, attempt := range attempts { overlay, _ := readOverlay(root, attempt.ID) fmt.Printf("%s [%s] goal=%s files=%d deps=%s", attempt.ID, attempt.Status, attempt.GoalID, len(overlay.Files), short(attempt.DependencyKey)) if attempt.SupersededBy != "" { fmt.Printf(" superseded-by=%s", attempt.SupersededBy) } if attempt.MountPath != "" { fmt.Printf(" mount=%s", attempt.MountPath) } fmt.Println() } return nil case "reject": if len(args.pos) < 3 { return errors.New("usage: hvn attempt reject attempt-id") } attempt, err := readAttempt(root, args.pos[2]) if err != nil { return err } attempt.Status = "rejected" attempt.SupersededBy = "" attempt.Decisions = append(attempt.Decisions, Record{Value: "rejected", CreatedAt: now()}) attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return err } fmt.Printf("Rejected %s.\n", attempt.ID) return nil case "rebase": if len(args.pos) < 3 { return errors.New("usage: hvn attempt rebase attempt-id") } args.pos = append([]string{"rebase"}, args.pos[2:]...) return cmdRebase(args) case "supersede": if len(args.pos) < 3 { return errors.New("usage: hvn attempt supersede attempt-id --by attempt-id") } byID := args.flags["by"] if byID == "" { return errors.New("missing --by") } if args.pos[2] == byID { return errors.New("attempt cannot supersede itself") } attempt, err := readAttempt(root, args.pos[2]) if err != nil { return err } successor, err := readAttempt(root, byID) if err != nil { return fmt.Errorf("superseding attempt %q: %w", byID, err) } attempt.Status = "superseded" attempt.SupersededBy = successor.ID attempt.Decisions = append(attempt.Decisions, Record{Value: "superseded", Note: "by " + successor.ID, CreatedAt: now()}) attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return err } fmt.Printf("Superseded %s by %s.\n", attempt.ID, successor.ID) return nil default: return errors.New("usage: hvn attempt list|rebase|reject|supersede") } } func cmdMount(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn mount attempt-id") } root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[1]) if err != nil { return err } attempt, err = materializeMount(root, attempt) if err != nil { return err } fmt.Println(attempt.MountPath) return nil } func materializeMount(root string, attempt Attempt) (Attempt, error) { mount := filepath.Join(root, hvnDir, "mounts", attempt.ID) if err := os.RemoveAll(mount); err != nil { return Attempt{}, err } if err := os.MkdirAll(mount, 0755); err != nil { return Attempt{}, err } base, err := readAttemptBase(root, attempt) if err != nil { return Attempt{}, err } for _, file := range base.Files { data, err := readObject(root, file.Hash) if err != nil { return Attempt{}, err } target := filepath.Join(mount, filepath.FromSlash(file.Path)) if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil { return Attempt{}, err } if err := os.WriteFile(target, data, os.FileMode(file.Mode)); err != nil { return Attempt{}, err } } overlay, err := readOverlay(root, attempt.ID) if err != nil { return Attempt{}, err } for _, file := range overlay.Files { target := filepath.Join(mount, filepath.FromSlash(file.Path)) if file.Status == "deleted" { if err := os.Remove(target); err != nil && !os.IsNotExist(err) { return Attempt{}, err } continue } data, err := readObject(root, file.CurrentHash) if err != nil { return Attempt{}, err } if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil { return Attempt{}, err } if err := os.WriteFile(target, data, 0644); err != nil { return Attempt{}, err } } attempt.MountPath = rel(root, mount) attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return Attempt{}, err } return attempt, nil } func cmdStatus(args parsedArgs) error { root, err := findRoot() if err != nil { return err } head, err := readHead(root) if err != nil { return err } changes, err := workingChanges(root) if err != nil { return err } goals, err := listGoals(root) if err != nil { return err } attempts, err := listAttempts(root) if err != nil { return err } if wantsJSON(args) { out := StatusJSON{ Head: head, BaseChanges: overlayFilesJSON(changes), Goals: goalsJSON(goals), Attempts: attemptStatusJSON(nil), } for _, attempt := range attempts { overlay, _ := readOverlay(root, attempt.ID) conflicts, err := conflictsFor(root, attempt, overlay) if err != nil { return err } out.Attempts = append(out.Attempts, AttemptStatusJSON{ Attempt: attempt, Overlay: overlayJSON(overlay), Conflicts: conflictsJSON(conflicts), Env: envStatusFor(root, attempt, overlay), Next: nextAttemptCommand(attempt, len(overlay.Files)), }) } return printJSON(out) } if head == "" { fmt.Println("HEAD: none") } else { fmt.Printf("HEAD: %s\n", head) } fmt.Printf("Base changes since HEAD: %d\n", len(changes)) for _, change := range changes { fmt.Printf(" %-8s %s\n", change.Status, change.Path) } fmt.Printf("Goals: %d\n", len(goals)) for _, goal := range goals { fmt.Printf(" %s [%s] %s\n", goal.ID, goal.Status, goal.Title) } fmt.Printf("Attempts: %d\n", len(attempts)) for _, attempt := range attempts { overlay, _ := readOverlay(root, attempt.ID) fmt.Printf(" %s [%s] goal=%s files=%d deps=%s", attempt.ID, attempt.Status, attempt.GoalID, len(overlay.Files), short(attempt.DependencyKey)) if attempt.SupersededBy != "" { fmt.Printf(" superseded-by=%s", attempt.SupersededBy) } if attempt.MountPath != "" { fmt.Printf(" mount=%s", attempt.MountPath) } fmt.Printf(" next=%s\n", nextAttemptCommand(attempt, len(overlay.Files))) } return nil } func nextAttemptCommand(attempt Attempt, changedFiles int) string { switch attempt.Status { case "active": if attempt.MountPath == "" { return "hvn mount " + attempt.ID } if changedFiles == 0 { return "edit " + attempt.MountPath } return "hvn submit " + attempt.ID + " --claim \"...\"" case "submitted": return "hvn review " + attempt.GoalID case "accepted": return "hvn commit -m \"...\"" case "superseded": if attempt.SupersededBy != "" { return "use " + attempt.SupersededBy } return "none" default: return "none" } } func cmdDiff(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn diff attempt-id") } root, attempt, overlay, err := reconcileForAttempt(args.pos[1]) if err != nil { return err } conflicts, err := conflictsFor(root, attempt, overlay) if err != nil { return err } if wantsJSON(args) { return printJSON(DiffJSON{Attempt: attempt, Overlay: overlayJSON(overlay), Conflicts: conflictsJSON(conflicts)}) } if len(overlay.Files) == 0 { fmt.Println("No overlay changes.") return nil } for _, file := range overlay.Files { rangeText := "" if file.StartLine > 0 { rangeText = fmt.Sprintf(" lines=%d-%d", file.StartLine, file.EndLine) } fmt.Printf("%-8s %s%s\n", file.Status, file.Path, rangeText) } printConflicts(conflicts) return nil } func cmdRebase(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn rebase attempt-id") } root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[1]) if err != nil { return err } if attempt.Status == "accepted" || attempt.Status == "rejected" || attempt.Status == "superseded" { return fmt.Errorf("attempt %s is %s", attempt.ID, attempt.Status) } previousBaseVersion := attempt.BaseVersion overlay, err := reconcileAttempt(root, attempt) if err != nil { return err } currentBase, err := readBase(root) if err != nil { return err } rebased, conflicts, err := rebaseOverlayOntoBase(root, attempt, overlay) if err != nil { return err } if len(conflicts) > 0 { if wantsJSON(args) { if err := printJSON(RebaseJSON{ Attempt: attempt, Overlay: overlayJSON(overlay), Conflicts: conflictsJSON(conflicts), PreviousBaseVersion: previousBaseVersion, CurrentBaseVersion: currentBase.Version, Rebased: false, }); err != nil { return err } return errors.New("refusing to rebase stale overlay with base conflicts") } printConflicts(conflicts) return errors.New("refusing to rebase stale overlay with base conflicts") } attempt.BaseVersion = currentBase.Version attempt.UpdatedAt = now() if err := writeOverlay(root, rebased); err != nil { return err } if err := writeAttempt(root, attempt); err != nil { return err } if attempt.MountPath != "" { attempt, err = materializeMount(root, attempt) if err != nil { return err } } if wantsJSON(args) { return printJSON(RebaseJSON{ Attempt: attempt, Overlay: overlayJSON(rebased), Conflicts: conflictsJSON(nil), PreviousBaseVersion: previousBaseVersion, CurrentBaseVersion: currentBase.Version, Rebased: true, }) } fmt.Printf("Rebased %s from base %s to %s with %d file(s).\n", attempt.ID, short(previousBaseVersion), short(currentBase.Version), len(rebased.Files)) return nil } func cmdIntegrate(args parsedArgs) error { root, err := findRoot() if err != nil { return err } if len(args.pos) > 1 && args.pos[1] == "resolve" { return cmdIntegrateResolve(root, args) } attemptIDs, err := integrateAttemptQueue(root, args) if err != nil { return err } if args.bools["dry-run"] { return cmdIntegrateDryRun(root, args, attemptIDs) } result := IntegrateJSON{Steps: []IntegrateStep{}} decision := args.flags["decision"] if decision == "" { decision = "integrated by hvn integrate" } for _, attemptID := range attemptIDs { step, err := integrateAttempt(root, attemptID, decision) result.Steps = append(result.Steps, step) if err != nil { result.Stopped = true result.Next = integrateNextCommand(step) if wantsJSON(args) { _ = printJSON(result) } else { printIntegrateStep(step) } return err } if !wantsJSON(args) { printIntegrateStep(step) } } message := args.flags["commit"] if message == "" { message = args.flags["message"] } if message != "" { commit, err := commitBase(root, message) if err != nil { result.Stopped = true result.Next = "hvn commit -m \"...\"" if wantsJSON(args) { _ = printJSON(result) } return err } result.Commit = commit if !wantsJSON(args) { fmt.Printf("Committed %s %s\n", commit.ID, commit.Message) } } if wantsJSON(args) { return printJSON(result) } return nil } func cmdIntegrateResolve(root string, args parsedArgs) error { sourceIDs, err := integrateResolveQueue(root, args) if err != nil { return err } sources, goalID, err := readResolveSources(root, args.flags["goal"], sourceIDs) if err != nil { return err } base, err := readBase(root) if err != nil { return err } resolver, err := createAgentAttempt(root, goalID, base, "Resolve integration conflicts for "+strings.Join(sourceIDs, ", ")) if err != nil { return err } resolver, err = materializeMount(root, resolver) if err != nil { return err } overlays := []OverlayManifest{{AttemptID: resolver.ID, UpdatedAt: now(), Files: []OverlayFile{}}} allConflicts := []Conflict{} for _, source := range sources { sourceOverlay, err := reconcileAttempt(root, source) if err != nil { return err } markers, err := conflictMarkerFiles(root, sourceOverlay) if err != nil { return err } if len(markers) > 0 { return fmt.Errorf("source attempt %s has unresolved conflict markers", source.ID) } rebased, conflicts, err := rebaseOverlayOntoBase(root, source, sourceOverlay) if err != nil { return err } allConflicts = append(allConflicts, conflicts...) if len(conflicts) > 0 { conflictOverlay, err := baseConflictMarkerOverlay(root, source, sourceOverlay, conflicts, base) if err != nil { return err } rebased.Files = append(rebased.Files, conflictOverlay.Files...) sort.Slice(rebased.Files, func(i, j int) bool { return rebased.Files[i].Path < rebased.Files[j].Path }) } overlays = append(overlays, rebased) } combined, crossConflicts, err := combineOverlays(root, resolver.ID, overlays) if err != nil { return err } allConflicts = append(allConflicts, crossConflicts...) if len(crossConflicts) > 0 { combined, err = combineOverlaysWithConflictMarkers(root, resolver.ID, overlays, crossConflicts) if err != nil { return err } } if err := writeOverlay(root, combined); err != nil { return err } resolver, err = materializeMount(root, resolver) if err != nil { return err } superseded := []string{} if args.bools["supersede"] { for _, source := range sources { source.Status = "superseded" source.SupersededBy = resolver.ID source.Decisions = append(source.Decisions, Record{Value: "superseded", Note: "resolver " + resolver.ID, CreatedAt: now()}) source.UpdatedAt = now() if err := writeAttempt(root, source); err != nil { return err } superseded = append(superseded, source.ID) } } markerFiles, err := conflictMarkerFiles(root, combined) if err != nil { return err } sortConflicts(allConflicts) if wantsJSON(args) { return printJSON(IntegrateResolveJSON{ Attempt: resolver, Overlay: overlayJSON(combined), Sources: stringsJSON(sourceIDs), Conflicts: conflictsJSON(allConflicts), Superseded: stringsJSON(superseded), MarkerFiles: stringsJSON(markerFiles), Next: "edit " + resolver.MountPath, }) } if len(allConflicts) > 0 { printConflicts(allConflicts) } fmt.Printf("Created resolver %s at %s with %d file(s)", resolver.ID, resolver.MountPath, len(combined.Files)) if len(markerFiles) > 0 { fmt.Printf(" and %d conflict marker file(s)", len(markerFiles)) } fmt.Println(".") if len(superseded) > 0 { fmt.Printf("Superseded %s.\n", strings.Join(superseded, ", ")) } return nil } func integrateResolveQueue(root string, args parsedArgs) ([]string, error) { explicit := args.pos[2:] goalID := args.flags["goal"] if goalID == "" { if len(explicit) == 0 { return nil, errors.New("usage: hvn integrate resolve attempt-id... [--goal goal-id] [--supersede] [--json]") } return explicit, nil } if len(explicit) > 0 { return nil, errors.New("hvn integrate resolve accepts either explicit attempt IDs or --goal, not both") } if _, err := readGoal(root, goalID); err != nil { return nil, err } attempts, err := listAttempts(root) if err != nil { return nil, err } queue := []string{} for _, attempt := range attempts { if attempt.GoalID == goalID && (attempt.Status == "active" || attempt.Status == "submitted") { queue = append(queue, attempt.ID) } } if len(queue) == 0 { return nil, fmt.Errorf("goal %s has no active or submitted attempts to resolve", goalID) } return queue, nil } func readResolveSources(root, requestedGoalID string, sourceIDs []string) ([]Attempt, string, error) { sources := []Attempt{} seen := map[string]bool{} goalID := requestedGoalID for _, id := range sourceIDs { if seen[id] { return nil, "", fmt.Errorf("duplicate resolve attempt %q", id) } seen[id] = true source, err := readAttempt(root, id) if err != nil { return nil, "", err } if source.Status == "accepted" || source.Status == "rejected" || source.Status == "superseded" { return nil, "", fmt.Errorf("source attempt %s is %s", source.ID, source.Status) } if goalID == "" { goalID = source.GoalID } if source.GoalID != goalID { return nil, "", fmt.Errorf("source attempt %s belongs to goal %s, not %s", source.ID, source.GoalID, goalID) } sources = append(sources, source) } if goalID == "" { return nil, "", errors.New("cannot infer resolver goal") } return sources, goalID, nil } func baseConflictMarkerOverlay(root string, source Attempt, overlay OverlayManifest, conflicts []Conflict, base BaseSnapshot) (OverlayManifest, error) { sourceFiles := map[string]OverlayFile{} for _, file := range overlay.Files { sourceFiles[file.Path] = file } baseMap := map[string]BaseFile{} for _, file := range base.Files { baseMap[file.Path] = file } entriesByPath := map[string][]combineEntry{} for _, path := range conflictPaths(conflicts) { sourceFile, ok := sourceFiles[path] if !ok { return OverlayManifest{}, fmt.Errorf("source attempt %s has no overlay entry for %s", source.ID, path) } baseFile := baseConflictSide(root, sourceFile, baseMap[path], baseMap[path].Path != "") entriesByPath[path] = []combineEntry{ {AttemptID: source.ID, File: sourceFile}, {AttemptID: "base", File: baseFile}, } } files := []OverlayFile{} for _, path := range conflictPaths(conflicts) { marker, err := conflictMarkerFile(root, path, entriesByPath[path]) if err != nil { return OverlayManifest{}, err } files = append(files, marker) } sort.Slice(files, func(i, j int) bool { return files[i].Path < files[j].Path }) return OverlayManifest{AttemptID: source.ID, UpdatedAt: now(), Files: files}, nil } func baseConflictSide(root string, source OverlayFile, currentBase BaseFile, currentExists bool) OverlayFile { if !currentExists { return OverlayFile{Path: source.Path, BaseHash: source.BaseHash, Status: "deleted", StartLine: 1, EndLine: max(1, source.EndLine)} } if source.Status == "added" { return OverlayFile{Path: source.Path, CurrentHash: currentBase.Hash, Status: "added", StartLine: 1, EndLine: max(1, countLinesInObject(root, currentBase.Hash))} } baseSide := OverlayFile{Path: source.Path, BaseHash: source.BaseHash, CurrentHash: currentBase.Hash, Status: "modified"} setChangedRange(root, &baseSide) return baseSide } func integrateAttemptQueue(root string, args parsedArgs) ([]string, error) { explicit := args.pos[1:] goalID := args.flags["goal"] if goalID == "" { if len(explicit) == 0 { return nil, errors.New("usage: hvn integrate attempt-id... [--dry-run] [--commit \"message\"] [--json]\n hvn integrate --goal goal-id [--dry-run] [--commit \"message\"] [--json]") } return explicit, nil } if len(explicit) > 0 { return nil, errors.New("hvn integrate accepts either explicit attempt IDs or --goal, not both") } if _, err := readGoal(root, goalID); err != nil { return nil, err } attempts, err := listAttempts(root) if err != nil { return nil, err } queue := []string{} for _, attempt := range attempts { if attempt.GoalID != goalID { continue } if attempt.Status == "active" || attempt.Status == "submitted" { queue = append(queue, attempt.ID) } } if len(queue) == 0 { return nil, fmt.Errorf("goal %s has no active or submitted attempts to integrate", goalID) } return queue, nil } func cmdIntegrateDryRun(root string, args parsedArgs, attemptIDs []string) error { base, err := readBase(root) if err != nil { return err } result := IntegrateJSON{Steps: []IntegrateStep{}, DryRun: true} for _, attemptID := range attemptIDs { step, nextBase, err := planIntegrateAttempt(root, attemptID, base) result.Steps = append(result.Steps, step) if err != nil { result.Stopped = true result.Next = integrateNextCommand(step) if wantsJSON(args) { _ = printJSON(result) } else { printIntegrateStep(step) } return err } base = nextBase if !wantsJSON(args) { printIntegrateStep(step) } } message := args.flags["commit"] if message == "" { message = args.flags["message"] } if message != "" { result.WouldCommit = true result.CommitMessage = message if !wantsJSON(args) { fmt.Printf("Would commit %q\n", message) } } if wantsJSON(args) { return printJSON(result) } return nil } func integrateAttempt(root, attemptID, decision string) (IntegrateStep, error) { attempt, err := readAttempt(root, attemptID) if err != nil { return IntegrateStep{AttemptID: attemptID, Status: "error", Message: err.Error()}, err } step := IntegrateStep{AttemptID: attempt.ID, Status: attempt.Status, PreviousBaseVersion: attempt.BaseVersion} if attempt.Status == "accepted" { step.Accepted = true step.Message = "already accepted" return step, nil } if attempt.Status == "rejected" || attempt.Status == "superseded" { step.Message = fmt.Sprintf("attempt is %s", attempt.Status) return step, fmt.Errorf("attempt %s is %s", attempt.ID, attempt.Status) } overlay, err := reconcileAttempt(root, attempt) if err != nil { step.Message = err.Error() return step, err } markers, err := conflictMarkerFiles(root, overlay) if err != nil { step.Message = err.Error() return step, err } if len(markers) > 0 { step.Message = "unresolved conflict markers" return step, fmt.Errorf("attempt %s has unresolved conflict markers", attempt.ID) } currentBase, err := readBase(root) if err != nil { step.Message = err.Error() return step, err } step.CurrentBaseVersion = currentBase.Version rebased, conflicts, err := rebaseOverlayOntoBase(root, attempt, overlay) if err != nil { step.Message = err.Error() return step, err } if len(conflicts) > 0 { step.Conflicts = conflictsJSON(conflicts) step.Message = "base conflicts" return step, fmt.Errorf("attempt %s has base conflicts", attempt.ID) } if err := writeOverlay(root, rebased); err != nil { step.Message = err.Error() return step, err } if err := applyOverlayFiles(root, rebased.Files); err != nil { step.Message = err.Error() return step, err } base, err := snapshotBase(root) if err != nil { step.Message = err.Error() return step, err } if err := writeBase(root, base); err != nil { step.Message = err.Error() return step, err } attempt.Status = "accepted" attempt.Decisions = append(attempt.Decisions, Record{Value: "accepted", Note: decision, CreatedAt: now()}) attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { step.Message = err.Error() return step, err } step.Status = attempt.Status step.Accepted = true step.Files = len(rebased.Files) step.CurrentBaseVersion = base.Version return step, nil } func planIntegrateAttempt(root, attemptID string, base BaseSnapshot) (IntegrateStep, BaseSnapshot, error) { attempt, err := readAttempt(root, attemptID) if err != nil { return IntegrateStep{AttemptID: attemptID, Status: "error", Message: err.Error()}, base, err } step := IntegrateStep{AttemptID: attempt.ID, Status: attempt.Status, PreviousBaseVersion: attempt.BaseVersion, CurrentBaseVersion: base.Version} if attempt.Status == "accepted" { step.Accepted = true step.Message = "already accepted" return step, base, nil } if attempt.Status == "rejected" || attempt.Status == "superseded" { step.Message = fmt.Sprintf("attempt is %s", attempt.Status) return step, base, fmt.Errorf("attempt %s is %s", attempt.ID, attempt.Status) } overlay, err := reconcileAttemptDryRun(root, attempt) if err != nil { step.Message = err.Error() return step, base, err } markers, err := conflictMarkerFiles(root, overlay) if err != nil { step.Message = err.Error() return step, base, err } if len(markers) > 0 { step.Message = "unresolved conflict markers" return step, base, fmt.Errorf("attempt %s has unresolved conflict markers", attempt.ID) } rebased, conflicts, err := rebaseOverlayOntoBaseSnapshot(root, attempt, overlay, base) if err != nil { step.Message = err.Error() return step, base, err } if len(conflicts) > 0 { step.Conflicts = conflictsJSON(conflicts) step.Message = "base conflicts" return step, base, fmt.Errorf("attempt %s has base conflicts", attempt.ID) } nextBase, err := applyOverlayToBaseSnapshot(root, base, rebased.Files) if err != nil { step.Message = err.Error() return step, base, err } step.Files = len(rebased.Files) step.WouldIntegrate = true step.CurrentBaseVersion = nextBase.Version return step, nextBase, nil } func applyOverlayToBaseSnapshot(root string, base BaseSnapshot, files []OverlayFile) (BaseSnapshot, error) { byPath := map[string]BaseFile{} for _, file := range base.Files { byPath[file.Path] = file } for _, file := range files { if file.Status == "deleted" { delete(byPath, file.Path) continue } if file.CurrentHash == "" { return BaseSnapshot{}, fmt.Errorf("cannot plan %s without current content", file.Path) } data, err := readObject(root, file.CurrentHash) if err != nil { return BaseSnapshot{}, err } byPath[file.Path] = BaseFile{Path: file.Path, Hash: file.CurrentHash, Size: int64(len(data)), Mode: 0644} } nextFiles := make([]BaseFile, 0, len(byPath)) for _, file := range byPath { nextFiles = append(nextFiles, file) } sort.Slice(nextFiles, func(i, j int) bool { return nextFiles[i].Path < nextFiles[j].Path }) versionInput := strings.Builder{} for _, file := range nextFiles { versionInput.WriteString(file.Path) versionInput.WriteString(file.Hash) } return BaseSnapshot{Version: hashString(versionInput.String()), CreatedAt: now(), Files: nextFiles}, nil } func applyOverlayFiles(root string, files []OverlayFile) error { for _, file := range files { target := filepath.Join(root, filepath.FromSlash(file.Path)) if file.Status == "deleted" { if err := os.Remove(target); err != nil && !os.IsNotExist(err) { return err } continue } data, err := readObject(root, file.CurrentHash) if err != nil { return err } if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil { return err } if err := os.WriteFile(target, data, 0644); err != nil { return err } } return nil } func printIntegrateStep(step IntegrateStep) { if step.Accepted { fmt.Printf("Integrated %s files=%d base=%s\n", step.AttemptID, step.Files, short(step.CurrentBaseVersion)) return } if step.WouldIntegrate { fmt.Printf("Would integrate %s files=%d base=%s\n", step.AttemptID, step.Files, short(step.CurrentBaseVersion)) return } if len(step.Conflicts) > 0 { printConflicts(step.Conflicts) } fmt.Printf("Stopped at %s: %s\n", step.AttemptID, step.Message) } func integrateNextCommand(step IntegrateStep) string { if len(step.Conflicts) > 0 { return "hvn rebase " + step.AttemptID } if step.Message == "unresolved conflict markers" { return "hvn resolve " + step.AttemptID } return "hvn status" } func cmdCombine(args parsedArgs) error { if len(args.pos) < 3 { return errors.New("usage: hvn combine target-attempt source-attempt... [--resolve] [--supersede]") } root, err := findRoot() if err != nil { return err } target, err := readAttempt(root, args.pos[1]) if err != nil { return err } if target.Status == "accepted" || target.Status == "rejected" || target.Status == "superseded" { return fmt.Errorf("target attempt %s is %s", target.ID, target.Status) } all := []OverlayManifest{} targetOverlay, err := reconcileAttempt(root, target) if err != nil { return err } all = append(all, targetOverlay) sources := []Attempt{} seen := map[string]bool{target.ID: true} for _, id := range args.pos[2:] { if seen[id] { return fmt.Errorf("duplicate combine attempt %q", id) } seen[id] = true source, err := readAttempt(root, id) if err != nil { return err } if source.Status == "accepted" || source.Status == "rejected" || source.Status == "superseded" { return fmt.Errorf("source attempt %s is %s", source.ID, source.Status) } overlay, err := reconcileAttempt(root, source) if err != nil { return err } all = append(all, overlay) sources = append(sources, source) } combined, conflicts, err := combineOverlays(root, target.ID, all) if err != nil { return err } if len(conflicts) > 0 { printConflicts(conflicts) if !args.bools["resolve"] { return errors.New("refusing to combine conflicted overlays") } combined, err = combineOverlaysWithConflictMarkers(root, target.ID, all, conflicts) if err != nil { return err } } if err := writeOverlay(root, combined); err != nil { return err } target.UpdatedAt = now() if err := writeAttempt(root, target); err != nil { return err } if args.bools["resolve"] && target.MountPath != "" { target, err = materializeMount(root, target) if err != nil { return err } } if args.bools["supersede"] { for _, source := range sources { source.Status = "superseded" source.SupersededBy = target.ID source.Decisions = append(source.Decisions, Record{Value: "superseded", Note: "combined into " + target.ID, CreatedAt: now()}) source.UpdatedAt = now() if err := writeAttempt(root, source); err != nil { return err } } } if len(conflicts) > 0 && args.bools["resolve"] { fmt.Printf("Combined %d source attempt(s) into %s with %d file(s) and %d conflict marker(s).\n", len(sources), target.ID, len(combined.Files), len(conflictPaths(conflicts))) return nil } fmt.Printf("Combined %d source attempt(s) into %s with %d file(s).\n", len(sources), target.ID, len(combined.Files)) return nil } func cmdSubmit(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn submit attempt-id --claim \"...\" [--evidence path]") } _, attempt, _, err := reconcileForAttempt(args.pos[1]) if err != nil { return err } root, _ := findRoot() claim := args.flags["claim"] if claim == "" { return errors.New("missing --claim") } attempt.Claims = append(attempt.Claims, Claim{Text: claim, CreatedAt: now()}) if evidence := args.flags["evidence"]; evidence != "" { attempt.Evidence = append(attempt.Evidence, Record{Value: evidence, CreatedAt: now()}) } attempt.Status = "submitted" attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return err } fmt.Printf("Submitted %s.\n", attempt.ID) return nil } func cmdReview(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn review [--remote remote] goal-id") } root, err := findRoot() if err != nil { return err } if remoteName := args.flags["remote"]; remoteName != "" { out, err := remoteReview(root, remoteName, args.pos[1]) if err != nil { return err } if wantsJSON(args) { return printJSON(out) } fmt.Printf("%s [%s] remote=%s\n%s\n", out.Goal.ID, out.Goal.Status, remoteName, out.Goal.Title) for _, attempt := range out.Attempts { fmt.Printf("\n%s [%s] files=%d conflicts=%d\n", attempt.Attempt.ID, attempt.Attempt.Status, len(attempt.Overlay.Files), len(attempt.Conflicts)) for _, claim := range attempt.Attempt.Claims { fmt.Printf(" claim: %s\n", claim.Text) } for _, evidence := range attempt.Attempt.Evidence { fmt.Printf(" evidence: %s\n", evidence.Value) } } return nil } goal, err := readGoal(root, args.pos[1]) if err != nil { return err } attempts, err := listAttempts(root) if err != nil { return err } if wantsJSON(args) { out := ReviewJSON{Goal: goal, Attempts: attemptReviewJSON(nil), Tasks: tasksForGoal(root, goal.ID), Plans: plansForGoal(root, goal.ID), Claims: claimsForGoal(root, goal.ID)} for _, attempt := range attempts { if attempt.GoalID != goal.ID { continue } overlay, _ := readOverlay(root, attempt.ID) conflicts, err := conflictsFor(root, attempt, overlay) if err != nil { return err } out.Attempts = append(out.Attempts, AttemptReviewJSON{ Attempt: attempt, Overlay: overlayJSON(overlay), Conflicts: conflictsJSON(conflicts), Preview: previewForReview(root, attempt.ID), Next: nextAttemptCommand(attempt, len(overlay.Files)), }) } return printJSON(out) } fmt.Printf("%s [%s]\n%s\n", goal.ID, goal.Status, goal.Title) if goal.CriteriaText != "" { fmt.Printf("\nCriteria:\n%s\n", strings.TrimSpace(goal.CriteriaText)) } for _, task := range tasksForGoal(root, goal.ID) { fmt.Printf(" task: %s [%s] %s\n", task.ID, task.Status, task.Title) } for _, claim := range claimsForGoal(root, goal.ID) { fmt.Printf(" claim-path: %s [%s] %s\n", claim.ID, claim.Status, claim.Path) } for _, attempt := range attempts { if attempt.GoalID != goal.ID { continue } overlay, _ := readOverlay(root, attempt.ID) fmt.Printf("\n%s [%s] files=%d mount=%s\n", attempt.ID, attempt.Status, len(overlay.Files), attempt.MountPath) for _, claim := range attempt.Claims { fmt.Printf(" claim: %s\n", claim.Text) } for _, evidence := range attempt.Evidence { fmt.Printf(" evidence: %s\n", evidence.Value) } } return nil } func cmdAccept(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn accept attempt-id") } root, attempt, overlay, err := reconcileForAttempt(args.pos[1]) if err != nil { return err } conflicts, err := conflictsFor(root, attempt, overlay) if err != nil { return err } if len(conflicts) > 0 && !args.bools["force"] { printConflicts(conflicts) return errors.New("refusing to accept conflicted overlay without --force") } if !args.bools["force"] { markers, err := conflictMarkerFiles(root, overlay) if err != nil { return err } if len(markers) > 0 { for _, path := range markers { fmt.Printf("UNRESOLVED %s\n", path) } return errors.New("refusing to accept overlay with unresolved conflict markers") } } if !args.bools["force"] { rebased, rebaseConflicts, err := rebaseOverlayOntoBase(root, attempt, overlay) if err != nil { return err } if len(rebaseConflicts) > 0 { printConflicts(rebaseConflicts) return errors.New("refusing to accept stale overlay with base conflicts without --force") } overlay = rebased if err := writeOverlay(root, overlay); err != nil { return err } } for _, file := range overlay.Files { target := filepath.Join(root, filepath.FromSlash(file.Path)) if file.Status == "deleted" { if err := os.Remove(target); err != nil && !os.IsNotExist(err) { return err } continue } data, err := readObject(root, file.CurrentHash) if err != nil { return err } if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil { return err } if err := os.WriteFile(target, data, 0644); err != nil { return err } } base, err := snapshotBase(root) if err != nil { return err } if err := writeBase(root, base); err != nil { return err } attempt.Status = "accepted" attempt.Decisions = append(attempt.Decisions, Record{Value: "accepted", Note: args.flags["decision"], CreatedAt: now()}) attempt.UpdatedAt = now() if err := writeAttempt(root, attempt); err != nil { return err } fmt.Printf("Accepted %s into base snapshot %s.\n", attempt.ID, short(base.Version)) return nil } func cmdExport(args parsedArgs) error { if len(args.pos) < 2 || args.pos[1] != "git" { return errors.New("usage: hvn export git --attempt attempt-id [--json]") } attemptID := args.flags["attempt"] if attemptID == "" && len(args.pos) > 2 { attemptID = args.pos[2] } if attemptID == "" { return errors.New("missing --attempt") } root, attempt, overlay, err := reconcileForAttempt(attemptID) if err != nil { return err } exportPath := filepath.Join(root, hvnDir, "exports", attempt.ID+".diff") file, err := os.Create(exportPath) if err != nil { return err } defer file.Close() for _, changed := range overlay.Files { if err := writeUnifiedDiff(root, file, changed); err != nil { return err } } result := ExportResult{AttemptID: attempt.ID, Format: "unified-diff", Path: rel(root, exportPath), Files: len(overlay.Files)} if wantsJSON(args) { return printJSON(result) } fmt.Println(result.Path) return nil } func cmdTest(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn test attempt-id [-- command...]") } root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[1]) if err != nil { return err } if attempt.MountPath == "" { if err := cmdMount(parsedArgs{pos: []string{"mount", attempt.ID}, flags: map[string]string{}, bools: map[string]bool{}}); err != nil { return err } attempt, _ = readAttempt(root, attempt.ID) } command := args.pos for i, token := range args.pos { if token == "--" && i+1 < len(args.pos) { command = args.pos[i+1:] break } } if len(command) < 3 { command = defaultTestCommand(root) } return runInMount(root, attempt, command) } func cmdPreview(args parsedArgs) error { if len(args.pos) < 2 { return errors.New("usage: hvn preview list|proxy|restart|stop|logs|attempt-id") } switch args.pos[1] { case "list": return cmdPreviewList(args) case "proxy": return cmdPreviewProxy(args) case "restart": return cmdPreviewRestart(args) case "stop": return cmdPreviewStop(args) case "logs": return cmdPreviewLogs(args) } return cmdPreviewStart(args) } func cmdPreviewList(args parsedArgs) error { root, err := findRoot() if err != nil { return err } previews, err := listPreviews(root) if err != nil { return err } if wantsJSON(args) { out := []PreviewJSON{} for _, preview := range previews { out = append(out, PreviewJSON{Preview: preview, Status: previewStatus(preview)}) } return printJSON(out) } if len(previews) == 0 { fmt.Println("No previews.") return nil } for _, preview := range previews { status := previewStatus(preview) fmt.Printf("%s [%s] %s pid=%d log=%s\n", preview.AttemptID, status, preview.URL, preview.PID, preview.LogPath) } return nil } func cmdPreviewRestart(args parsedArgs) error { if len(args.pos) < 3 { return errors.New("usage: hvn preview restart attempt-id [-- command...]") } root, err := findRoot() if err != nil { return err } attemptID := args.pos[2] command := previewCommandFromArgs(args) if len(command) == 0 { if existing, err := readPreview(root, attemptID); err == nil && len(existing.Command) > 0 { command = existing.Command } } if existing, err := readPreview(root, attemptID); err == nil && previewStatus(existing) == "running" { if err := stopProcess(existing.PID); err != nil { return err } existing.Status = "stopped" existing.StoppedAt = now() existing.UpdatedAt = existing.StoppedAt if err := writePreview(root, existing); err != nil { return err } } next := parsedArgs{pos: []string{"preview", attemptID}, flags: args.flags, bools: args.bools} if len(command) > 0 { next.pos = append(next.pos, "--") next.pos = append(next.pos, command...) } return cmdPreviewStart(next) } func cmdPreviewStop(args parsedArgs) error { if len(args.pos) < 3 { return errors.New("usage: hvn preview stop attempt-id") } root, err := findRoot() if err != nil { return err } preview, err := readPreview(root, args.pos[2]) if err != nil { return err } status := previewStatus(preview) if status == "running" { if err := stopProcess(preview.PID); err != nil { return err } } stoppedAt := now() preview.Status = "stopped" preview.StoppedAt = stoppedAt preview.UpdatedAt = stoppedAt if err := writePreview(root, preview); err != nil { return err } if status == "running" { fmt.Printf("Stopped preview %s.\n", preview.AttemptID) } else { fmt.Printf("Preview %s was not running.\n", preview.AttemptID) } return nil } func cmdPreviewLogs(args parsedArgs) error { if len(args.pos) < 3 { return errors.New("usage: hvn preview logs attempt-id") } root, err := findRoot() if err != nil { return err } preview, err := readPreview(root, args.pos[2]) if err != nil { return err } logPath := preview.LogPath if !filepath.IsAbs(logPath) { logPath = filepath.Join(root, logPath) } data, err := os.ReadFile(logPath) if err != nil { return err } text := string(data) if raw := args.flags["tail"]; raw != "" { lines, err := strconv.Atoi(raw) if err != nil { return fmt.Errorf("invalid --tail value %q", raw) } text = tailText(text, lines) } fmt.Print(text) if args.bools["follow"] && previewStatus(preview) == "running" { offset := len(data) for processRunning(preview.PID) { time.Sleep(200 * time.Millisecond) next, err := os.ReadFile(logPath) if err != nil { return err } if len(next) > offset { fmt.Print(string(next[offset:])) offset = len(next) } } } return nil } func cmdPreviewStart(args parsedArgs) error { root, err := findRoot() if err != nil { return err } attempt, err := readAttempt(root, args.pos[1]) if err != nil { return err } if attempt.MountPath == "" { if err := cmdMount(parsedArgs{pos: []string{"mount", attempt.ID}, flags: map[string]string{}, bools: map[string]bool{}}); err != nil { return err } attempt, _ = readAttempt(root, attempt.ID) } command := previewCommandFromArgs(args) if len(command) == 0 { command = defaultPreviewCommand(root) } if existing, err := readPreview(root, attempt.ID); err == nil && previewStatus(existing) == "running" { if err := stopProcess(existing.PID); err != nil { return err } existing.Status = "stopped" existing.StoppedAt = now() existing.UpdatedAt = existing.StoppedAt if err := writePreview(root, existing); err != nil { return err } } port, err := freePort() if err != nil { return err } mount := filepath.Join(root, attempt.MountPath) logPath := filepath.Join(root, hvnDir, "previews", attempt.ID+".log") logFile, err := os.Create(logPath) if err != nil { return err } defer logFile.Close() cmd := exec.Command(command[0], command[1:]...) cmd.Dir = mount cmd.Env = append(os.Environ(), "PORT="+strconv.Itoa(port)) cmd.Stdout = logFile cmd.Stderr = logFile isolateProcessGroup(cmd) if err := cmd.Start(); err != nil { return err } createdAt := now() preview := Preview{ AttemptID: attempt.ID, Port: port, PID: cmd.Process.Pid, URL: "http://localhost:" + strconv.Itoa(port), LogPath: rel(root, logPath), Command: command, MountPath: attempt.MountPath, Status: "running", CreatedAt: createdAt, UpdatedAt: createdAt, } if err := writePreview(root, preview); err != nil { return err } fmt.Printf("%s pid=%d log=%s\n", preview.URL, preview.PID, preview.LogPath) return nil } func previewCommandFromArgs(args parsedArgs) []string { for i, token := range args.pos { if token == "--" && i+1 < len(args.pos) { return args.pos[i+1:] } } return nil } func tailText(text string, lines int) string { if lines <= 0 { return "" } parts := strings.SplitAfter(text, "\n") if len(parts) > 0 && parts[len(parts)-1] == "" { parts = parts[:len(parts)-1] } if lines >= len(parts) { return text } return strings.Join(parts[len(parts)-lines:], "") } func previewStatus(preview Preview) string { if preview.Status == "stopped" { return "stopped" } if processRunning(preview.PID) { return "running" } return "exited" }

Overview

Project State

Recent Commits

File Tree

Selected Files

Remote Artifacts

Artifact, Download, And Clone Commands