felixm/antidrift
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add settings page implementation plan

Browse Source 
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Felix Martin
2026-06-01 19:53:27 -04:00
parent 3fdbfd307b
commit ae5cec3dce
1 changed files with 996 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/superpowers/plans/2026-06-01-settings-page.md
+996
View File
@@ -0,0 +1,996 @@
# Settings file + settings page Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Let the user edit the AI backend, Marvin tasks command, and knowledge profile path at runtime from a settings page in the web UI, persisted to a settings file, with a server-side file picker for the profile path.
**Architecture:** A new leaf `internal/settings` package owns the `Settings` struct and its JSON file (`~/.antidrift/settings.json`). `main.go` builds an `applyFn func(settings.Settings) error` closure that constructs adapters and calls the controller's existing setters, and injects it into the web server. The server's `POST /settings` handler validates-and-applies via that closure (atomically — invalid backend mutates nothing), then persists. A `GET /fs/browse` endpoint backs a custom file-picker modal. `web` never imports `ai`/`tasks`/`knowledge`.
**Tech Stack:** Go, Gin, vanilla-JS SSE frontend. Spec: `docs/superpowers/specs/2026-06-01-settings-page-design.md`.
---
## File structure
- `internal/settings/settings.go` (new) — `Settings` struct, `ErrInvalidBackend`, `DefaultPath`, `Load`, `Save`, `SeedFromEnv`.
- `internal/settings/settings_test.go` (new) — round-trip, seed, first-run.
- `internal/web/settings_handlers.go` (new) — server settings fields, `SetSettings`, `handleGetSettings`, `handlePostSettings`, `handleBrowse`.
- `internal/web/settings_handlers_test.go` (new) — GET/POST/browse tests with a fake applier.
- `internal/web/web.go` (modify) — register routes; drop `POST /knowledge/path` + `handleKnowledgePath`.
- `cmd/antidriftd/main.go` (modify) — load-or-seed settings, build `applyFn`, inject into server.
- `internal/web/static/index.html` (modify) — gear button + overlay container.
- `internal/web/static/app.js` (modify) — settings overlay + browse modal; repoint knowledge "change" link.
- `internal/web/static/app.css` (modify) — gear, overlay, modal, browse styles.
---
## Task 1: `internal/settings` package
**Files:**
- Create: `internal/settings/settings.go`
- Test: `internal/settings/settings_test.go`
- [ ] **Step 1: Write the failing tests**
Create `internal/settings/settings_test.go`:
```go
package settings
import (
"os"
"path/filepath"
"testing"
)
func TestSaveLoadRoundTrip(t *testing.T) {
path := filepath.Join(t.TempDir(), "settings.json")
want := Settings{AIBackend: "codex", MarvinCmd: "uv run am", KnowledgePath: "/tmp/k.md"}
if err := Save(path, want); err != nil {
t.Fatalf("save: %v", err)
}
got, err := Load(path)
if err != nil {
t.Fatalf("load: %v", err)
}
if got != want {
t.Errorf("round trip = %+v, want %+v", got, want)
}
}
func TestLoadMissingFileIsError(t *testing.T) {
_, err := Load(filepath.Join(t.TempDir(), "nope.json"))
if err == nil {
t.Fatal("want error loading missing file, got nil")
}
}
func TestSeedFromEnvReadsVars(t *testing.T) {
t.Setenv("ANTIDRIFT_AI_BACKEND", "codex")
t.Setenv("ANTIDRIFT_MARVIN_CMD", "uv run am")
t.Setenv("ANTIDRIFT_KNOWLEDGE_FILE", "/tmp/k.md")
got := SeedFromEnv()
want := Settings{AIBackend: "codex", MarvinCmd: "uv run am", KnowledgePath: "/tmp/k.md"}
if got != want {
t.Errorf("SeedFromEnv = %+v, want %+v", got, want)
}
}
func TestSeedFromEnvDefaultsBackend(t *testing.T) {
t.Setenv("ANTIDRIFT_AI_BACKEND", "")
t.Setenv("ANTIDRIFT_MARVIN_CMD", "")
t.Setenv("ANTIDRIFT_KNOWLEDGE_FILE", "")
got := SeedFromEnv()
if got.AIBackend != "claude" {
t.Errorf("default backend = %q, want claude", got.AIBackend)
}
}
func TestSaveCreatesDir(t *testing.T) {
path := filepath.Join(t.TempDir(), "sub", "settings.json")
if err := Save(path, Settings{AIBackend: "claude"}); err != nil {
t.Fatalf("save: %v", err)
}
if _, err := os.Stat(path); err != nil {
t.Fatalf("file not written: %v", err)
}
}
```
- [ ] **Step 2: Run tests to verify they fail**
Run: `go test ./internal/settings/`
Expected: FAIL — `undefined: Settings`, `undefined: Save`, etc.
- [ ] **Step 3: Write the implementation**
Create `internal/settings/settings.go`:
```go
// Package settings persists the daemon's user-editable configuration as a single
// JSON file (~/.antidrift/settings.json), parallel to the store snapshot. It is a
// leaf type package: it imports nothing else in the app so any layer may depend
// on the Settings value without pulling in adapters.
package settings
import (
"encoding/json"
"errors"
"os"
"path/filepath"
)
// ErrInvalidBackend marks a settings value whose ai_backend is not a known
// backend. The applier returns it (wrapped) so the HTTP layer can map it to 400
// without importing the ai package.
var ErrInvalidBackend = errors.New("settings: invalid ai backend")
// Settings is the user-editable configuration. Field names mirror the env vars
// they replace: ANTIDRIFT_AI_BACKEND, ANTIDRIFT_MARVIN_CMD, ANTIDRIFT_KNOWLEDGE_FILE.
type Settings struct {
AIBackend string `json:"ai_backend"`
MarvinCmd string `json:"marvin_cmd"`
KnowledgePath string `json:"knowledge_path"`
}
// DefaultPath returns ~/.antidrift/settings.json.
func DefaultPath() (string, error) {
home, err := os.UserHomeDir()
if err != nil {
return "", err
}
return filepath.Join(home, ".antidrift", "settings.json"), nil
}
// Load reads a settings file. A missing file is an error; callers treat that as
// "first run" and seed instead.
func Load(path string) (Settings, error) {
data, err := os.ReadFile(path)
if err != nil {
return Settings{}, err
}
var s Settings
if err := json.Unmarshal(data, &s); err != nil {
return Settings{}, err
}
return s, nil
}
// Save writes settings atomically (temp file + rename), creating the directory
// if needed. Mirrors store.Save.
func Save(path string, s Settings) error {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return err
}
data, err := json.MarshalIndent(s, "", " ")
if err != nil {
return err
}
tmp := path + ".tmp"
if err := os.WriteFile(tmp, data, 0o644); err != nil {
return err
}
return os.Rename(tmp, path)
}
// SeedFromEnv builds a Settings from the legacy ANTIDRIFT_* env vars, applying
// the same defaults the daemon used before the settings file existed. An unset
// AI backend defaults to "claude" (matching ai.NewBackend("")).
func SeedFromEnv() Settings {
backend := os.Getenv("ANTIDRIFT_AI_BACKEND")
if backend == "" {
backend = "claude"
}
return Settings{
AIBackend: backend,
MarvinCmd: os.Getenv("ANTIDRIFT_MARVIN_CMD"),
KnowledgePath: os.Getenv("ANTIDRIFT_KNOWLEDGE_FILE"),
}
}
```
- [ ] **Step 4: Run tests to verify they pass**
Run: `go test ./internal/settings/`
Expected: PASS (all 5 tests).
- [ ] **Step 5: Commit**
```bash
git add internal/settings/
git commit -m "Add settings package: Settings file load/save/seed
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Task 2: Web settings handlers (GET + POST)
**Files:**
- Create: `internal/web/settings_handlers.go`
- Test: `internal/web/settings_handlers_test.go`
- [ ] **Step 1: Write the failing tests**
Create `internal/web/settings_handlers_test.go`:
```go
package web
import (
"encoding/json"
"net/http"
"os"
"path/filepath"
"testing"
"antidrift/internal/settings"
)
// fakeApplier records the last settings it was asked to apply and can be told to
// reject with ErrInvalidBackend.
type fakeApplier struct {
called int
last settings.Settings
reject bool
}
func (f *fakeApplier) apply(s settings.Settings) error {
if f.reject {
return settings.ErrInvalidBackend
}
f.called++
f.last = s
return nil
}
func TestGetSettingsReturnsCurrent(t *testing.T) {
s := newTestServer(t)
cur := settings.Settings{AIBackend: "claude", MarvinCmd: "am", KnowledgePath: "/tmp/k.md"}
fa := &fakeApplier{}
s.SetSettings(filepath.Join(t.TempDir(), "settings.json"), cur, fa.apply)
r := s.Router()
req := httptest.NewRequest(http.MethodGet, "/settings", nil)
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
var got settings.Settings
if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
t.Fatalf("decode: %v", err)
}
if got != cur {
t.Errorf("got %+v, want %+v", got, cur)
}
}
func TestPostSettingsValidAppliesAndSaves(t *testing.T) {
s := newTestServer(t)
path := filepath.Join(t.TempDir(), "settings.json")
fa := &fakeApplier{}
s.SetSettings(path, settings.Settings{}, fa.apply)
r := s.Router()
body := `{"ai_backend":"codex","marvin_cmd":"uv run am","knowledge_path":"/tmp/k.md"}`
w := post(t, r, "/settings", body)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", w.Code, w.Body.String())
}
if fa.called != 1 {
t.Fatalf("applier called %d times, want 1", fa.called)
}
if fa.last.AIBackend != "codex" {
t.Errorf("applied backend = %q, want codex", fa.last.AIBackend)
}
if _, err := os.Stat(path); err != nil {
t.Errorf("settings file not written: %v", err)
}
}
func TestPostSettingsInvalidBackendIs400AndNoSave(t *testing.T) {
s := newTestServer(t)
path := filepath.Join(t.TempDir(), "settings.json")
fa := &fakeApplier{reject: true}
s.SetSettings(path, settings.Settings{}, fa.apply)
r := s.Router()
w := post(t, r, "/settings", `{"ai_backend":"bogus"}`)
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400", w.Code)
}
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Errorf("settings file should not exist after rejected save, stat err = %v", err)
}
}
```
Note: `httptest`, `post`, and `newTestServer` already exist in `web_test.go` (same package), so they are reused here.
- [ ] **Step 2: Run tests to verify they fail**
Run: `go test ./internal/web/ -run TestSettings -v` (and `TestGetSettings`, `TestPostSettings`)
Run: `go test ./internal/web/ -run 'Settings' -v`
Expected: FAIL — `s.SetSettings undefined`.
- [ ] **Step 3: Write the implementation**
Create `internal/web/settings_handlers.go`:
```go
package web
import (
"net/http"
"antidrift/internal/settings"
"github.com/gin-gonic/gin"
)
// SetSettings injects the persisted settings, their file path, and the applier
// closure (built by main, which owns adapter construction). Mirrors the
// controller's Set* injection so web never imports ai/tasks/knowledge.
func (s *Server) SetSettings(path string, current settings.Settings, apply func(settings.Settings) error) {
s.settingsMu.Lock()
s.settingsPath = path
s.settings = current
s.applyFn = apply
s.settingsMu.Unlock()
}
func (s *Server) handleGetSettings(c *gin.Context) {
s.settingsMu.Lock()
cur := s.settings
s.settingsMu.Unlock()
c.JSON(http.StatusOK, cur)
}
// handlePostSettings validates-and-applies atomically, then persists. The applier
// checks the backend before mutating any state, so an invalid backend yields 400
// with nothing saved and the prior wiring intact.
func (s *Server) handlePostSettings(c *gin.Context) {
var req settings.Settings
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid json"})
return
}
s.settingsMu.Lock()
apply := s.applyFn
path := s.settingsPath
s.settingsMu.Unlock()
if apply == nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "settings not wired"})
return
}
if err := apply(req); err != nil {
// Apply validates the backend before mutating anything, so any error
// (invalid backend or otherwise) means nothing changed; surface it as 400.
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if err := settings.Save(path, req); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
s.settingsMu.Lock()
s.settings = req
s.settingsMu.Unlock()
s.broadcast()
c.JSON(http.StatusOK, req)
}
```
Add the server fields. In `internal/web/web.go`, modify the `Server` struct (currently lines 26-32) to:
```go
// Server wires the session controller to HTTP and SSE.
type Server struct {
ctrl *session.Controller
bcast *Broadcaster
mu sync.Mutex
timer *time.Timer
settingsMu sync.Mutex
settings settings.Settings
settingsPath string
applyFn func(settings.Settings) error
}
```
Add the import `"antidrift/internal/settings"` to `web.go`'s import block.
Register the routes in `internal/web/web.go` `Router()`, after the existing `r.POST(...)` lines (around line 71):
```go
r.GET("/settings", s.handleGetSettings)
r.POST("/settings", s.handlePostSettings)
```
- [ ] **Step 4: Run tests to verify they pass**
Run: `go test ./internal/web/ -run 'Settings' -v`
Expected: PASS (3 tests).
- [ ] **Step 5: Commit**
```bash
git add internal/web/settings_handlers.go internal/web/settings_handlers_test.go internal/web/web.go
git commit -m "Add GET/POST /settings handlers with injected applier
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Task 3: `GET /fs/browse` file-list endpoint
**Files:**
- Modify: `internal/web/settings_handlers.go`
- Test: `internal/web/settings_handlers_test.go`
- [ ] **Step 1: Write the failing test**
Append to `internal/web/settings_handlers_test.go`:
```go
func TestBrowseListsDirsAndMarkdown(t *testing.T) {
dir := t.TempDir()
if err := os.Mkdir(filepath.Join(dir, "sub"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "profile.md"), []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
s := newTestServer(t)
s.SetSettings(filepath.Join(t.TempDir(), "settings.json"), settings.Settings{}, func(settings.Settings) error { return nil })
r := s.Router()
req := httptest.NewRequest(http.MethodGet, "/fs/browse?dir="+dir, nil)
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
var resp struct {
Dir string `json:"dir"`
Parent string `json:"parent"`
Entries []struct {
Name string `json:"name"`
Path string `json:"path"`
IsDir bool `json:"is_dir"`
} `json:"entries"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if resp.Parent != filepath.Dir(dir) {
t.Errorf("parent = %q, want %q", resp.Parent, filepath.Dir(dir))
}
var names []string
for _, e := range resp.Entries {
names = append(names, e.Name)
}
hasSub, hasMd, hasTxt := false, false, false
for _, e := range resp.Entries {
switch e.Name {
case "sub":
hasSub = e.IsDir
case "profile.md":
hasMd = !e.IsDir
case "notes.txt":
hasTxt = true
}
}
if !hasSub || !hasMd {
t.Errorf("missing dir or .md entry; names = %v", names)
}
if hasTxt {
t.Errorf(".txt should be filtered out; names = %v", names)
}
}
func TestBrowseBadDirIs400(t *testing.T) {
s := newTestServer(t)
s.SetSettings(filepath.Join(t.TempDir(), "settings.json"), settings.Settings{}, func(settings.Settings) error { return nil })
r := s.Router()
req := httptest.NewRequest(http.MethodGet, "/fs/browse?dir=/no/such/dir/xyz", nil)
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400", w.Code)
}
}
```
- [ ] **Step 2: Run tests to verify they fail**
Run: `go test ./internal/web/ -run TestBrowse -v`
Expected: FAIL — 404 (route not registered) / `handleBrowse undefined`.
- [ ] **Step 3: Write the implementation**
Append to `internal/web/settings_handlers.go` (add `"os"`, `"path/filepath"`, `"strings"` to its imports):
```go
type browseEntry struct {
Name string `json:"name"`
Path string `json:"path"`
IsDir bool `json:"is_dir"`
}
type browseResponse struct {
Dir string `json:"dir"`
Parent string `json:"parent"`
Entries []browseEntry `json:"entries"`
}
// handleBrowse lists subdirectories plus .md files under dir, so the UI can build
// a file picker that returns a real server-side path. Dotfiles are NOT hidden —
// the default profile lives under ~/.antidrift. Localhost-only daemon; no jail
// beyond OS permissions (same trust boundary as the rest of the UI).
func (s *Server) handleBrowse(c *gin.Context) {
dir := strings.TrimSpace(c.Query("dir"))
if dir == "" {
dir = s.browseStart()
}
dir = filepath.Clean(dir)
infos, err := os.ReadDir(dir)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
resp := browseResponse{Dir: dir, Parent: filepath.Dir(dir), Entries: []browseEntry{}}
for _, e := range infos {
name := e.Name()
full := filepath.Join(dir, name)
if e.IsDir() {
resp.Entries = append(resp.Entries, browseEntry{Name: name, Path: full, IsDir: true})
} else if strings.HasSuffix(name, ".md") {
resp.Entries = append(resp.Entries, browseEntry{Name: name, Path: full})
}
}
c.JSON(http.StatusOK, resp)
}
// browseStart picks the directory of the current knowledge path, else $HOME.
func (s *Server) browseStart() string {
s.settingsMu.Lock()
kp := s.settings.KnowledgePath
s.settingsMu.Unlock()
if kp != "" {
return filepath.Dir(kp)
}
if home, err := os.UserHomeDir(); err == nil {
return home
}
return "/"
}
```
Register the route in `internal/web/web.go` `Router()`, next to the other settings routes:
```go
r.GET("/fs/browse", s.handleBrowse)
```
- [ ] **Step 4: Run tests to verify they pass**
Run: `go test ./internal/web/ -run TestBrowse -v`
Expected: PASS (2 tests).
- [ ] **Step 5: Commit**
```bash
git add internal/web/settings_handlers.go internal/web/settings_handlers_test.go internal/web/web.go
git commit -m "Add GET /fs/browse directory-listing endpoint
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Task 4: Remove the now-redundant `/knowledge/path` endpoint
**Files:**
- Modify: `internal/web/web.go`
- [ ] **Step 1: Delete the route and handler**
In `internal/web/web.go`, remove the route registration line:
```go
r.POST("/knowledge/path", s.handleKnowledgePath)
```
and delete the `knowledgePathRequest` type plus the `handleKnowledgePath` function (currently `web.go:143-159`):
```go
type knowledgePathRequest struct {
Path string `json:"path"`
}
// handleKnowledgePath repoints the profile file at runtime ...
func (s *Server) handleKnowledgePath(c *gin.Context) {
...
}
```
The controller's `SetKnowledgePath` method stays — the applier (Task 5) calls it.
- [ ] **Step 2: Update the test that exercises the removed route**
Search for any test referencing `/knowledge/path`:
Run: `grep -rn "knowledge/path" internal/web/`
If `TestPlanningStatePayloadCarriesKnowledge` (or any test) POSTs to `/knowledge/path`, repoint it to `/settings`. Concretely, replace a call like
`post(t, r, "/knowledge/path", `+"`"+`{"path":"/tmp/x.md"}`+"`"+`)`
with wiring settings first and posting the full object:
```go
s.SetSettings(filepath.Join(t.TempDir(), "settings.json"),
settings.Settings{}, func(settings.Settings) error { return nil })
post(t, r, "/settings", `{"ai_backend":"claude","marvin_cmd":"","knowledge_path":"/tmp/x.md"}`)
```
If no test references it, skip this step.
- [ ] **Step 3: Verify build and tests**
Run: `go build ./... && go test ./internal/web/`
Expected: PASS, no references to `handleKnowledgePath` remain.
Run: `grep -rn "knowledge/path\|handleKnowledgePath" internal/`
Expected: no matches.
- [ ] **Step 4: Commit**
```bash
git add internal/web/
git commit -m "Remove /knowledge/path; folded into /settings
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Task 5: Wire settings into `main.go` (applier + first-run seed)
**Files:**
- Modify: `cmd/antidriftd/main.go`
- [ ] **Step 1: Replace the env-var wiring with settings load-or-seed + applier**
In `cmd/antidriftd/main.go`, replace the three wiring blocks (currently lines 39-65: the AI backend block, the `SetTasks` block, and the `SetKnowledge` block) with the following. Keep everything before (`store.DefaultPath`, `session.New`, `web.NewServer`, `srv.Init()`) and after (statusfile, guard, evidence, browser, Run) unchanged.
```go
// Resolve and load settings, seeding from the legacy ANTIDRIFT_* env vars on
// first run. After first run the file is the sole source of truth; env is
// ignored. A missing file is the first-run signal.
settingsPath, err := settings.DefaultPath()
if err != nil {
log.Fatalf("resolve settings path: %v", err)
}
cfg, err := settings.Load(settingsPath)
if err != nil {
cfg = settings.SeedFromEnv()
if err := settings.Save(settingsPath, cfg); err != nil {
log.Printf("settings: could not write %s (continuing): %v", settingsPath, err)
} else {
log.Printf("settings: seeded %s from environment", settingsPath)
}
}
// The knowledge source is a single file adapter whose path is driven entirely
// by SetKnowledgePath, so startup and live settings edits share one code path.
ctrl.SetKnowledge(knowledge.NewFileSource(""))
// applyFn re-wires the running daemon from a Settings value: AI backend +
// service (coach/drift/nudge/reviewer), tasks command, and knowledge path. It
// validates the backend FIRST and mutates nothing on failure, so POST /settings
// can reject an invalid backend atomically.
applyFn := func(s settings.Settings) error {
backend, err := ai.NewBackend(s.AIBackend)
if err != nil {
return fmt.Errorf("%w: %v", settings.ErrInvalidBackend, err)
}
svc := ai.NewService(backend)
ctrl.SetCoach(svc)
ctrl.SetDriftJudge(svc)
ctrl.SetNudge(svc)
ctrl.SetReviewer(svc)
ctrl.SetTasks(tasks.NewMarvin(s.MarvinCmd))
ctrl.SetKnowledgePath(s.KnowledgePath)
return nil
}
// Apply once at startup. A bad persisted backend should not be fatal: fall back
// to claude (always valid), persist the correction, and re-apply.
if err := applyFn(cfg); err != nil {
log.Printf("settings: %v; falling back to claude backend", err)
cfg.AIBackend = "claude"
_ = settings.Save(settingsPath, cfg)
if err := applyFn(cfg); err != nil {
log.Fatalf("settings: apply failed even with claude: %v", err)
}
}
srv.SetSettings(settingsPath, cfg, applyFn)
log.Printf("settings: ai=%s, marvin=%q, knowledge=%q", cfg.AIBackend, cfg.MarvinCmd, cfg.KnowledgePath)
```
Add `"fmt"` and `"antidrift/internal/settings"` to the import block. The `"os"` import may become unused (it was only used for `os.Getenv`) — check: `openBrowser` does not use `os`. Remove `"os"` from the import block if `go build` reports it unused.
- [ ] **Step 2: Verify build**
Run: `go build ./...`
Expected: success. If it reports `"os" imported and not used`, remove the `"os"` import line and rebuild.
- [ ] **Step 3: Run the full test suite + vet**
Run: `go test ./... && go vet ./...`
Expected: all packages PASS, vet clean.
- [ ] **Step 4: Manual smoke test**
Run (no env vars needed now):
```bash
go run ./cmd/antidriftd
```
Expected log lines include `settings: seeded ... from environment` (first run) or `settings: ai=claude, ...`. Confirm `~/.antidrift/settings.json` exists:
Run: `cat ~/.antidrift/settings.json`
Expected: JSON with the three keys.
Stop the daemon (Ctrl-C).
- [ ] **Step 5: Commit**
```bash
git add cmd/antidriftd/main.go
git commit -m "Drive daemon config from settings file via injected applier
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Task 6: Settings UI — gear, overlay, browse modal
**Files:**
- Modify: `internal/web/static/index.html`
- Modify: `internal/web/static/app.js`
- Modify: `internal/web/static/app.css`
This task has no Go test harness (the repo has no JS tests); verification is `go build` + manual browser check. Write the exact code below.
- [ ] **Step 1: Add the gear button and overlay container to `index.html`**
Replace the `<main id="app">…</main>` block (lines 12-15) with:
```html
<main id="app">
<h1>AntiDrift <button id="gear" type="button" class="gear" title="Settings" aria-label="Settings">⚙</button></h1>
<div class="card" id="view">connecting…</div>
<div id="settingsOverlay" class="overlay" hidden></div>
</main>
```
The overlay lives OUTSIDE `#view`, so the SSE re-render (which replaces `view.innerHTML`) never wipes it.
- [ ] **Step 2: Repoint the knowledge "change" link in `app.js`**
In `internal/web/static/app.js`, in `updatePlanningKnowledge` (lines 184-187), replace the prompt-based handler:
```js
document.getElementById('knowChange').onclick = () => {
const next = prompt('Profile file path (blank = default):', k.path || '');
if (next !== null) post('/knowledge/path', { path: next.trim() });
};
```
with:
```js
document.getElementById('knowChange').onclick = openSettings;
```
- [ ] **Step 3: Append the settings overlay + browse logic to `app.js`**
Add at the end of `internal/web/static/app.js`, AFTER the `EventSource` block:
```js
// ---- Settings overlay ----
function openSettings() {
fetch('/settings').then(r => r.json()).then(s => {
const ov = document.getElementById('settingsOverlay');
ov.innerHTML = `
<div class="modal">
<h2>Settings</h2>
<label>AI backend</label>
<select id="setBackend">
<option value="claude">claude</option>
<option value="codex">codex</option>
</select>
<label>Marvin tasks command</label>
<input id="setMarvin" placeholder="uv run am">
<label>Knowledge profile path</label>
<div class="path-row">
<input id="setKnow" placeholder="~/.antidrift/knowledge.md">
<button type="button" class="btn btn-ghost" id="setBrowse">Browse…</button>
</div>
<div id="browsePane" class="browse" hidden></div>
<div id="setError" class="set-error"></div>
<div class="modal-actions">
<button type="button" class="btn btn-ghost" id="setCancel">Cancel</button>
<button type="button" class="btn btn-primary" id="setSave">Save</button>
</div>
</div>`;
document.getElementById('setBackend').value = s.ai_backend || 'claude';
document.getElementById('setMarvin').value = s.marvin_cmd || '';
document.getElementById('setKnow').value = s.knowledge_path || '';
ov.hidden = false;
document.getElementById('setCancel').onclick = closeSettings;
document.getElementById('setSave').onclick = saveSettings;
document.getElementById('setBrowse').onclick = () =>
loadBrowse(parentDir(document.getElementById('setKnow').value));
});
}
function closeSettings() {
const ov = document.getElementById('settingsOverlay');
ov.hidden = true;
ov.innerHTML = '';
}
function saveSettings() {
const body = {
ai_backend: document.getElementById('setBackend').value,
marvin_cmd: document.getElementById('setMarvin').value.trim(),
knowledge_path: document.getElementById('setKnow').value.trim(),
};
post('/settings', body).then(r => {
if (r.ok) { closeSettings(); return; }
return r.json().then(e => {
document.getElementById('setError').textContent = e.error || 'save failed';
});
});
}
function parentDir(path) {
if (!path) return '';
return path.replace(/\/[^/]*$/, '');
}
function loadBrowse(dir) {
const pane = document.getElementById('browsePane');
pane.hidden = false;
fetch('/fs/browse?dir=' + encodeURIComponent(dir || '')).then(r => {
if (!r.ok) return r.json().then(e => { throw new Error(e.error || 'cannot read directory'); });
return r.json();
}).then(d => {
const items = [];
if (d.parent && d.parent !== d.dir) {
items.push(`<li><button type="button" data-dir="${d.parent}">../</button></li>`);
}
for (const e of d.entries) {
if (e.is_dir) {
items.push(`<li><button type="button" data-dir="${e.path}">${e.name}/</button></li>`);
} else {
items.push(`<li><button type="button" data-file="${e.path}">${e.name}</button></li>`);
}
}
pane.innerHTML = `<div class="browse-dir">${d.dir}</div><ul class="browse-list">${items.join('')}</ul>`;
pane.querySelectorAll('button[data-dir]').forEach(b =>
b.onclick = () => loadBrowse(b.getAttribute('data-dir')));
pane.querySelectorAll('button[data-file]').forEach(b =>
b.onclick = () => {
document.getElementById('setKnow').value = b.getAttribute('data-file');
pane.hidden = true;
pane.innerHTML = '';
});
}).catch(err => {
pane.innerHTML = `<div class="set-error">${err.message}</div>`;
});
}
document.getElementById('gear').onclick = openSettings;
```
- [ ] **Step 4: Add styles to `app.css`**
Append to `internal/web/static/app.css`:
```css
/* Settings: header gear + overlay modal */
.gear {
background: none; border: 0; color: var(--ink-dim); cursor: pointer;
font-size: 14px; padding: 0 4px; vertical-align: middle;
}
.gear:hover { color: var(--accent); }
.overlay {
position: fixed; inset: 0; background: rgba(0,0,0,.5);
display: flex; align-items: flex-start; justify-content: center;
padding: 8vh 16px; z-index: 10;
}
.overlay[hidden] { display: none; }
.modal {
width: 100%; max-width: 520px; background: var(--panel);
border: 1px solid var(--line); border-radius: 14px; padding: 20px;
}
.modal h2 { margin: 0 0 12px; font-size: 16px; }
.modal-actions { margin-top: 16px; display: flex; gap: 8px; justify-content: flex-end; }
.modal-actions .btn { margin-top: 0; }
.path-row { display: flex; gap: 8px; align-items: center; }
.path-row input { flex: 1; }
.path-row .btn { margin-top: 0; white-space: nowrap; }
.set-error { color: var(--danger); font-size: 13px; margin-top: 8px; min-height: 1em; }
.browse {
margin-top: 10px; border: 1px solid var(--line); border-radius: 8px;
background: var(--bg); max-height: 260px; overflow-y: auto;
}
.browse[hidden] { display: none; }
.browse-dir {
padding: 8px 10px; font-size: 12px; color: var(--ink-dim);
font-family: ui-monospace, monospace; border-bottom: 1px solid var(--line);
position: sticky; top: 0; background: var(--bg);
}
.browse-list { list-style: none; margin: 0; padding: 4px 0; }
.browse-list button {
width: 100%; text-align: left; background: none; border: 0; cursor: pointer;
color: var(--ink); font: inherit; font-size: 13px; padding: 5px 12px;
font-family: ui-monospace, monospace;
}
.browse-list button:hover { background: var(--line); color: var(--accent); }
```
- [ ] **Step 5: Build and manual-verify in browser**
Static assets are `//go:embed`-ed, so a rebuild is required for changes to load.
Run: `go build ./... && go vet ./...`
Expected: success, vet clean.
Then run the daemon and hard-reload the browser (Ctrl-Shift-R):
```bash
go run ./cmd/antidriftd
```
Manual checklist (verify each):
1. A gear (⚙) shows next to the "AntiDrift" header.
2. Clicking it opens the settings overlay with backend/marvin/knowledge prefilled from `~/.antidrift/settings.json`.
3. Clicking **Browse…** lists the knowledge path's directory; clicking folders navigates, `../` goes up, clicking a `.md` file fills the path field and closes the browser pane.
4. Changing the backend to `codex` and Save closes the overlay; `cat ~/.antidrift/settings.json` shows `"ai_backend":"codex"`.
5. The planning screen's knowledge "change" link opens the same settings overlay.
Stop the daemon (Ctrl-C).
- [ ] **Step 6: Commit**
```bash
git add internal/web/static/
git commit -m "Add settings gear, overlay, and file-browser modal to the UI
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
```
---
## Final verification
- [ ] Run `go build ./... && go test ./... && go vet ./...` — all green.
- [ ] Run `grep -rn "os.Getenv" cmd/ internal/` — expect no matches (all config now flows through the settings file).
- [ ] Confirm `~/.antidrift/settings.json` round-trips a UI edit (change marvin command in UI, reload page, value persists).
</content>