xonecas.io
62159
Sy

symb / commit 2c756b5

feat: undo

xonecas2026-02-14 2c756b5e45df339432835c9302cef061a8b039b5 parent 9f01e43

15 files changed

README.md+1−0
@@ -25,6 +25,7 @@ Symb pairs you with an LLM, providing an agentic UI with tools the LLM can use t
2525 - **ELM architecture**: Built with BubbleTea for solid state management
2626 - **LLM integration**: Ollama local + Opencode Zen support
2727 - **Hashline-assisted edits**: LLM edit operations use line hashes for precise, conflict-free file modifications
28+- **UNDO!**: You're always able to undo file changes. Best effort undo, tracks working directory changes deltas.
2829 - **Web search**: Exa AI integration with configurable SQLite cache and content-aware redundant search prevention
2930 - **Git integration**: Diff viewing and change tracking for version control awareness
3031 - **LSP diagnostics**: Closed-loop edit validation with language server feedback
cmd/symb/main.go+30−14
@@ -13,6 +13,7 @@ import (
1313 "github.com/rs/zerolog"
1414 "github.com/rs/zerolog/log"
1515 "github.com/xonecas/symb/internal/config"
16+ "github.com/xonecas/symb/internal/delta"
1617 "github.com/xonecas/symb/internal/lsp"
1718 "github.com/xonecas/symb/internal/mcp"
1819 "github.com/xonecas/symb/internal/mcptools"
@@ -85,8 +86,13 @@ func main() {
8586 svc.readHandler.SetTSIndex(tsIndex)
8687 svc.editHandler.SetTSIndex(tsIndex)
8788
89+ // Set session on delta tracker so file deltas are linked.
90+ if svc.deltaTracker != nil {
91+ svc.deltaTracker.SetSession(sessionID)
92+ }
93+
8894 p := tea.NewProgram(
89- tui.New(prov, svc.proxy, tools, providerCfg.Model, svc.webCache, sessionID, tsIndex),
95+ tui.New(prov, svc.proxy, tools, providerCfg.Model, svc.webCache, sessionID, tsIndex, svc.deltaTracker, svc.fileTracker),
9096 tea.WithFilter(tui.MouseEventFilter),
9197 )
9298 svc.lspManager.SetCallback(func(absPath string, lines map[int]int) {
@@ -132,11 +138,13 @@ func resolveProvider(cfg *config.Config, registry *provider.Registry) (string, c
132138 }
133139
134140 type services struct {
135- proxy *mcp.Proxy
136- lspManager *lsp.Manager
137- webCache *store.Cache
138- readHandler *mcptools.ReadHandler
139- editHandler *mcptools.EditHandler
141+ proxy *mcp.Proxy
142+ lspManager *lsp.Manager
143+ webCache *store.Cache
144+ readHandler *mcptools.ReadHandler
145+ editHandler *mcptools.EditHandler
146+ fileTracker *mcptools.FileReadTracker
147+ deltaTracker *delta.Tracker
140148 }
141149
142150 func setupServices(cfg *config.Config, creds *config.Credentials) services {
@@ -157,22 +165,30 @@ func setupServices(cfg *config.Config, creds *config.Credentials) services {
157165
158166 proxy.RegisterTool(mcptools.NewGrepTool(), mcptools.MakeGrepHandler())
159167
160- editHandler := mcptools.NewEditHandler(fileTracker, lspManager)
161- proxy.RegisterTool(mcptools.NewEditTool(), editHandler.Handle)
162-
163168 webCache := openWebCache(cfg)
164169
170+ // Create delta tracker for undo support, sharing the same DB.
171+ var dt *delta.Tracker
172+ if webCache != nil {
173+ dt = delta.New(webCache.DB())
174+ }
175+
176+ editHandler := mcptools.NewEditHandler(fileTracker, lspManager, dt)
177+ proxy.RegisterTool(mcptools.NewEditTool(), editHandler.Handle)
178+
165179 proxy.RegisterTool(mcptools.NewWebFetchTool(), mcptools.MakeWebFetchHandler(webCache))
166180
167181 exaKey := creds.GetAPIKey("exa_ai")
168182 proxy.RegisterTool(mcptools.NewWebSearchTool(), mcptools.MakeWebSearchHandler(webCache, exaKey, ""))
169183
170184 return services{
171- proxy: proxy,
172- lspManager: lspManager,
173- webCache: webCache,
174- readHandler: readHandler,
175- editHandler: editHandler,
185+ proxy: proxy,
186+ lspManager: lspManager,
187+ webCache: webCache,
188+ readHandler: readHandler,
189+ editHandler: editHandler,
190+ fileTracker: fileTracker,
191+ deltaTracker: dt,
176192 }
177193 }
178194
docs/DESIGN.md+3−2
@@ -98,13 +98,14 @@ Parse project with tree-sitter for structural awareness. Feed relevant
9898 symbols/scope to LLM as auto-context instead of whole files.
9999 **Uses 4k tokens on a small project like this** -- ohoh... Maybe return updated treesiter information with Grep matches for less token usage overall? Context inhection then can reduced/compacted?
100100
101-## Features waiting implementation for current version:
102-
103101 ### Undo!
104102
105103 - User should be able to undo conversation turns. The most recent entry should show a clear clickable area labelled undo.
106104 - Clicking undo reverses context history, tool calls, filesystem changes, file changes. Resets the conversation to that exact point
107105
106+
107+## Features waiting implementation for current version:
108+
108109 ### Shell Execution Tool
109110
110111 Run commands in sandbox (container isolation or restricted shell). Command
internal/delta/delta.go+145−0
@@ -0,0 +1,145 @@
1+// Package delta tracks filesystem changes made by tool calls so they can be
2+// reversed on undo. Deltas are persisted to SQLite and keyed by (session, turn).
3+package delta
4+
5+import (
6+ "database/sql"
7+ "os"
8+ "sync"
9+
10+ "github.com/rs/zerolog/log"
11+)
12+
13+// Tracker records and replays filesystem deltas.
14+type Tracker struct {
15+ mu sync.Mutex
16+ db *sql.DB
17+ sessionID string
18+ turnID int64 // current turn; 0 = no active turn
19+}
20+
21+// New creates a Tracker that writes to the given database.
22+func New(db *sql.DB) *Tracker {
23+ return &Tracker{db: db}
24+}
25+
26+// SetSession sets the active session ID.
27+func (t *Tracker) SetSession(id string) {
28+ t.mu.Lock()
29+ defer t.mu.Unlock()
30+ t.sessionID = id
31+}
32+
33+// BeginTurn sets the current turn ID. All subsequent Record* calls
34+// are associated with this turn until the next BeginTurn.
35+func (t *Tracker) BeginTurn(turnID int64) {
36+ t.mu.Lock()
37+ defer t.mu.Unlock()
38+ t.turnID = turnID
39+}
40+
41+// TurnID returns the current turn ID.
42+func (t *Tracker) TurnID() int64 {
43+ t.mu.Lock()
44+ defer t.mu.Unlock()
45+ return t.turnID
46+}
47+
48+// RecordModify stores the original content of a file before it is modified.
49+// Only the first snapshot per file per turn is kept (subsequent edits to the
50+// same file in the same turn are no-ops — we already have the original).
51+func (t *Tracker) RecordModify(filePath string, oldContent []byte) {
52+ t.mu.Lock()
53+ defer t.mu.Unlock()
54+ if t.turnID == 0 || t.sessionID == "" {
55+ return
56+ }
57+ // Check if we already have a delta for this file in this turn.
58+ var exists bool
59+ err := t.db.QueryRow(
60+ `SELECT 1 FROM file_deltas WHERE session_id = ? AND turn_id = ? AND file_path = ? LIMIT 1`,
61+ t.sessionID, t.turnID, filePath,
62+ ).Scan(&exists)
63+ if err == nil && exists {
64+ return // already recorded
65+ }
66+ _, err = t.db.Exec(
67+ `INSERT INTO file_deltas (session_id, turn_id, file_path, op, old_content, created)
68+ VALUES (?, ?, ?, 'modify', ?, strftime('%s','now'))`,
69+ t.sessionID, t.turnID, filePath, oldContent,
70+ )
71+ if err != nil {
72+ log.Warn().Err(err).Str("file", filePath).Msg("failed to record modify delta")
73+ }
74+}
75+
76+// RecordCreate records that a file was created (old_content is NULL).
77+func (t *Tracker) RecordCreate(filePath string) {
78+ t.mu.Lock()
79+ defer t.mu.Unlock()
80+ if t.turnID == 0 || t.sessionID == "" {
81+ return
82+ }
83+ _, err := t.db.Exec(
84+ `INSERT INTO file_deltas (session_id, turn_id, file_path, op, old_content, created)
85+ VALUES (?, ?, ?, 'create', NULL, strftime('%s','now'))`,
86+ t.sessionID, t.turnID, filePath,
87+ )
88+ if err != nil {
89+ log.Warn().Err(err).Str("file", filePath).Msg("failed to record create delta")
90+ }
91+}
92+
93+// Undo reverses all file changes for the given turn, in reverse order.
94+// Modify ops restore old content; create ops delete the file.
95+// Returns the list of affected absolute file paths and any error.
96+func (t *Tracker) Undo(sessionID string, turnID int64) ([]string, error) {
97+ t.mu.Lock()
98+ defer t.mu.Unlock()
99+
100+ rows, err := t.db.Query(
101+ `SELECT file_path, op, old_content FROM file_deltas
102+ WHERE session_id = ? AND turn_id = ?
103+ ORDER BY id DESC`,
104+ sessionID, turnID,
105+ )
106+ if err != nil {
107+ return nil, err
108+ }
109+ defer rows.Close()
110+
111+ var affected []string
112+ for rows.Next() {
113+ var filePath, op string
114+ var oldContent []byte
115+ if err := rows.Scan(&filePath, &op, &oldContent); err != nil {
116+ log.Warn().Err(err).Msg("failed to scan delta row")
117+ continue
118+ }
119+ affected = append(affected, filePath)
120+ switch op {
121+ case "modify":
122+ if err := os.WriteFile(filePath, oldContent, 0600); err != nil {
123+ log.Warn().Err(err).Str("file", filePath).Msg("undo: failed to restore file")
124+ }
125+ case "create":
126+ if err := os.Remove(filePath); err != nil && !os.IsNotExist(err) {
127+ log.Warn().Err(err).Str("file", filePath).Msg("undo: failed to remove created file")
128+ }
129+ }
130+ }
131+ return affected, rows.Err()
132+}
133+
134+// DeleteTurn removes all delta records for a turn.
135+func (t *Tracker) DeleteTurn(sessionID string, turnID int64) {
136+ t.mu.Lock()
137+ defer t.mu.Unlock()
138+ _, err := t.db.Exec(
139+ `DELETE FROM file_deltas WHERE session_id = ? AND turn_id = ?`,
140+ sessionID, turnID,
141+ )
142+ if err != nil {
143+ log.Warn().Err(err).Int64("turn", turnID).Msg("failed to delete turn deltas")
144+ }
145+}
internal/mcptools/edit.go+15−5
@@ -9,6 +9,7 @@ import (
99 "strings"
1010 "time"
1111
12+ "github.com/xonecas/symb/internal/delta"
1213 "github.com/xonecas/symb/internal/hashline"
1314 "github.com/xonecas/symb/internal/lsp"
1415 "github.com/xonecas/symb/internal/mcp"
@@ -109,14 +110,15 @@ After each edit you receive fresh hashes — use those for subsequent edits, not
109110
110111 // EditHandler handles Edit tool calls.
111112 type EditHandler struct {
112- tracker *FileReadTracker
113- lspManager *lsp.Manager
114- tsIndex *treesitter.Index
113+ tracker *FileReadTracker
114+ lspManager *lsp.Manager
115+ tsIndex *treesitter.Index
116+ deltaTracker *delta.Tracker
115117 }
116118
117119 // NewEditHandler creates a handler for the Edit tool.
118-func NewEditHandler(tracker *FileReadTracker, lspManager *lsp.Manager) *EditHandler {
119- return &EditHandler{tracker: tracker, lspManager: lspManager}
120+func NewEditHandler(tracker *FileReadTracker, lspManager *lsp.Manager, dt *delta.Tracker) *EditHandler {
121+ return &EditHandler{tracker: tracker, lspManager: lspManager, deltaTracker: dt}
120122 }
121123
122124 // SetTSIndex sets the tree-sitter index for incremental updates on edit.
@@ -193,6 +195,10 @@ func (h *EditHandler) applyEdit(ctx context.Context, absPath string, args EditAr
193195 return toolError("%v", err), nil
194196 }
195197
198+ if h.deltaTracker != nil {
199+ h.deltaTracker.RecordModify(absPath, content)
200+ }
201+
196202 if err := os.WriteFile(absPath, []byte(result), 0600); err != nil {
197203 return toolError("Failed to write file: %v", err), nil
198204 }
@@ -225,6 +231,10 @@ func (h *EditHandler) handleCreate(ctx context.Context, absPath, displayPath str
225231 return toolError("Failed to create directories: %v", err), nil
226232 }
227233
234+ if h.deltaTracker != nil {
235+ h.deltaTracker.RecordCreate(absPath)
236+ }
237+
228238 if err := os.WriteFile(absPath, []byte(op.Content), 0600); err != nil {
229239 return toolError("Failed to create file: %v", err), nil
230240 }
internal/mcptools/edit_test.go+7−7
@@ -36,7 +36,7 @@ func newTrackedHandler(t *testing.T, absPath string) *EditHandler {
3636 t.Helper()
3737 tracker := NewFileReadTracker()
3838 tracker.MarkRead(absPath)
39- return NewEditHandler(tracker, nil)
39+ return NewEditHandler(tracker, nil, nil)
4040 }
4141
4242 func callEdit(t *testing.T, handler *EditHandler, args EditArgs) (string, bool) {
@@ -159,7 +159,7 @@ func TestEditCreate(t *testing.T) {
159159 defer os.Chdir(origDir) //nolint:errcheck
160160
161161 tracker := NewFileReadTracker()
162- handler := NewEditHandler(tracker, nil)
162+ handler := NewEditHandler(tracker, nil, nil)
163163 text, isErr := callEdit(t, handler, EditArgs{
164164 File: "newfile.go",
165165 Create: &CreateOp{Content: "package main\n\nfunc main() {}\n"},
@@ -184,7 +184,7 @@ func TestEditCreateFailsIfExists(t *testing.T) {
184184 defer cleanup()
185185
186186 tracker := NewFileReadTracker()
187- handler := NewEditHandler(tracker, nil)
187+ handler := NewEditHandler(tracker, nil, nil)
188188 _, isErr := callEdit(t, handler, EditArgs{
189189 File: "test.go",
190190 Create: &CreateOp{Content: "new content"},
@@ -220,7 +220,7 @@ func TestEditNoOperation(t *testing.T) {
220220 defer cleanup()
221221
222222 tracker := NewFileReadTracker()
223- handler := NewEditHandler(tracker, nil)
223+ handler := NewEditHandler(tracker, nil, nil)
224224 _, isErr := callEdit(t, handler, EditArgs{
225225 File: "test.go",
226226 })
@@ -262,7 +262,7 @@ func TestEditPathTraversal(t *testing.T) {
262262 defer cleanup()
263263
264264 tracker := NewFileReadTracker()
265- handler := NewEditHandler(tracker, nil)
265+ handler := NewEditHandler(tracker, nil, nil)
266266 _, isErr := callEdit(t, handler, EditArgs{
267267 File: "../../../etc/passwd",
268268 Create: &CreateOp{Content: "hacked"},
@@ -339,7 +339,7 @@ func TestEditRequiresReadFirst(t *testing.T) {
339339
340340 // Handler with empty tracker — file NOT read
341341 tracker := NewFileReadTracker()
342- handler := NewEditHandler(tracker, nil)
342+ handler := NewEditHandler(tracker, nil, nil)
343343
344344 text, isErr := callEdit(t, handler, EditArgs{
345345 File: filepath.Base(path),
@@ -385,7 +385,7 @@ func TestEditCreateBypassesReadCheck(t *testing.T) {
385385
386386 // Empty tracker — no file read. Create should still work.
387387 tracker := NewFileReadTracker()
388- handler := NewEditHandler(tracker, nil)
388+ handler := NewEditHandler(tracker, nil, nil)
389389 _, isErr := callEdit(t, handler, EditArgs{
390390 File: "brand-new.go",
391391 Create: &CreateOp{Content: "package new\n"},
internal/mcptools/filetrack.go+7−0
@@ -28,3 +28,10 @@ func (t *FileReadTracker) WasRead(absPath string) bool {
2828 _, ok := t.read[absPath]
2929 return ok
3030 }
31+
32+// Reset clears all read records (used on undo).
33+func (t *FileReadTracker) Reset() {
34+ t.mu.Lock()
35+ defer t.mu.Unlock()
36+ t.read = make(map[string]struct{})
37+}
internal/store/session.go+62−0
@@ -60,6 +60,10 @@ func (c *Cache) SaveMessage(sessionID string, msg SessionMessage) {
6060 func (c *Cache) saveLoop() {
6161 defer close(c.done)
6262 for req := range c.saveCh {
63+ if req.flush != nil {
64+ close(req.flush)
65+ continue
66+ }
6367 c.writeMessage(req.sessionID, req.msg)
6468 }
6569 }
@@ -87,6 +91,64 @@ func (c *Cache) writeMessage(sessionID string, msg SessionMessage) {
8791 c.db.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID) //nolint:errcheck
8892 }
8993
94+// SaveMessageSync persists a message synchronously and returns its DB row ID.
95+// Used for turn-start messages where we need the ID immediately.
96+func (c *Cache) SaveMessageSync(sessionID string, msg SessionMessage) (int64, error) {
97+ if c == nil {
98+ return 0, nil
99+ }
100+ c.mu.Lock()
101+ defer c.mu.Unlock()
102+
103+ tc := msg.ToolCalls
104+ if tc == nil {
105+ tc = json.RawMessage("[]")
106+ }
107+
108+ res, err := c.db.Exec(
109+ `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created)
110+ VALUES (?, ?, ?, ?, ?, ?, ?)`,
111+ sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(),
112+ )
113+ if err != nil {
114+ return 0, err
115+ }
116+
117+ c.db.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID) //nolint:errcheck
118+
119+ return res.LastInsertId()
120+}
121+
122+// Flush blocks until all queued async saves have been written to the DB.
123+// Times out after 5 seconds to avoid deadlocking the caller.
124+func (c *Cache) Flush() {
125+ if c == nil {
126+ return
127+ }
128+ done := make(chan struct{})
129+ select {
130+ case c.saveCh <- saveReq{flush: done}:
131+ <-done
132+ case <-time.After(5 * time.Second):
133+ log.Warn().Msg("flush timed out waiting to enqueue")
134+ }
135+}
136+
137+// DeleteMessagesFrom removes all messages with id >= minID for a session.
138+func (c *Cache) DeleteMessagesFrom(sessionID string, minID int64) error {
139+ if c == nil {
140+ return nil
141+ }
142+ c.mu.Lock()
143+ defer c.mu.Unlock()
144+
145+ _, err := c.db.Exec(
146+ "DELETE FROM messages WHERE session_id = ? AND id >= ?",
147+ sessionID, minID,
148+ )
149+ return err
150+}
151+
90152 // LoadMessages returns all messages for a session, ordered by ID.
91153 func (c *Cache) LoadMessages(sessionID string) ([]SessionMessage, error) {
92154 if c == nil {
internal/store/store.go+21−0
@@ -47,12 +47,25 @@ CREATE TABLE IF NOT EXISTS messages (
4747 );
4848
4949 CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, id);
50+
51+CREATE TABLE IF NOT EXISTS file_deltas (
52+ id INTEGER PRIMARY KEY AUTOINCREMENT,
53+ session_id TEXT NOT NULL,
54+ turn_id INTEGER NOT NULL,
55+ file_path TEXT NOT NULL,
56+ op TEXT NOT NULL,
57+ old_content BLOB,
58+ created INTEGER NOT NULL
59+);
60+
61+CREATE INDEX IF NOT EXISTS idx_deltas_turn ON file_deltas(session_id, turn_id);
5062 `
5163
5264 // saveReq is an internal message sent to the background save goroutine.
5365 type saveReq struct {
5466 sessionID string
5567 msg SessionMessage
68+ flush chan struct{} // if non-nil, signal after processing (used by Flush)
5669 }
5770
5871 // Cache is a SQLite-backed cache for web results and session storage.
@@ -107,6 +120,14 @@ func Open(dbPath string, ttl time.Duration) (*Cache, error) {
107120 return c, nil
108121 }
109122
123+// DB returns the underlying *sql.DB for shared access (e.g. delta tracker).
124+func (c *Cache) DB() *sql.DB {
125+ if c == nil {
126+ return nil
127+ }
128+ return c.db
129+}
130+
110131 // Close drains pending saves and closes the database.
111132 func (c *Cache) Close() error {
112133 if c == nil {
internal/tui/conv.go+6−0
@@ -126,6 +126,12 @@ func (m Model) makeSeparator(dur string, ts string) string {
126126 return m.styles.Dim.Render(label + strings.Repeat("─", fill))
127127 }
128128
129+// makeUndoEntry creates a convEntry for the undo control.
130+// sepDisplay is the styled separator text to restore if this entry is demoted.
131+func (m Model) makeUndoEntry(sepDisplay string) convEntry {
132+ return convEntry{display: m.styles.Dim.Render("undo"), kind: entryUndo, full: sepDisplay}
133+}
134+
129135 // visibleStartLine returns the index of the first visible wrapped conversation line.
130136 func (m *Model) visibleStartLine() int {
131137 lines := m.wrappedConvLines()
internal/tui/golden_test.go+1−1
@@ -26,7 +26,7 @@ func TestLayout(t *testing.T) {
2626
2727 for _, tt := range tests {
2828 t.Run(tt.name, func(t *testing.T) {
29- m := New(nil, nil, nil, "test-model", nil, "test-session", nil)
29+ m := New(nil, nil, nil, "test-model", nil, "test-session", nil, nil, nil)
3030 updated, _ := m.Update(tea.WindowSizeMsg{Width: tt.width, Height: tt.height})
3131 m = updated.(Model)
3232
internal/tui/messages.go+3−0
@@ -40,6 +40,9 @@ type llmErrorMsg struct{ err error }
4040 type llmContentDeltaMsg struct{ content string }
4141 type llmReasoningDeltaMsg struct{ content string }
4242
43+// undoMsg is sent when the user clicks the undo control.
44+type undoMsg struct{}
45+
4346 // llmBatchMsg carries multiple messages drained from updateChan in one go.
4447 type llmBatchMsg []tea.Msg
4548
internal/tui/mouse.go+8−0
@@ -241,6 +241,9 @@ func (m *Model) isClickableLine(lineIdx int) bool {
241241 if m.convEntries[entryIdx].kind == entryToolResult {
242242 return true
243243 }
244+ if m.convEntries[entryIdx].kind == entryUndo {
245+ return true
246+ }
244247 if lineIdx >= len(lines) {
245248 return false
246249 }
@@ -264,6 +267,11 @@ func (m *Model) handleConvClick(wrappedLine int) tea.Cmd {
264267 }
265268 entry := m.convEntries[entryIdx]
266269
270+ // Undo control: emit undoMsg
271+ if entry.kind == entryUndo {
272+ return func() tea.Msg { return undoMsg{} }
273+ }
274+
267275 // Tool result: open the source file or fall back to raw content
268276 if entry.kind == entryToolResult {
269277 if entry.filePath != "" {
internal/tui/tui.go+30−1
@@ -10,6 +10,7 @@ import (
1010 tea "charm.land/bubbletea/v2"
1111 "charm.land/lipgloss/v2"
1212 "github.com/xonecas/symb/internal/constants"
13+ "github.com/xonecas/symb/internal/delta"
1314 "github.com/xonecas/symb/internal/llm"
1415 "github.com/xonecas/symb/internal/mcp"
1516 "github.com/xonecas/symb/internal/provider"
@@ -109,6 +110,8 @@ type entryKind int
109110 const (
110111 entryText entryKind = iota // Plain text (user, assistant, separator)
111112 entryToolResult // Tool result — clickable to view full content in editor
113+ entryUndo // Undo control — clickable to undo last turn
114+ entrySeparator // Demoted undo — a turn-end separator that can be re-promoted
112115 )
113116
114117 // convEntry is a single logical entry in the conversation pane.
@@ -148,6 +151,22 @@ func (s convSelection) ordered() (start, end convPos) {
148151
149152 func (s convSelection) empty() bool { return s.anchor == s.active }
150153
154+// FileReadResetter allows clearing the file read tracker on undo.
155+type FileReadResetter interface {
156+ Reset()
157+}
158+
159+// ---------------------------------------------------------------------------
160+// Turn tracking (for undo)
161+// ---------------------------------------------------------------------------
162+
163+// turnBoundary marks the start of a user turn in both history and convEntries.
164+type turnBoundary struct {
165+ historyIdx int // index in m.history where the user message is
166+ convIdx int // index in m.convEntries where this turn's display starts
167+ dbMsgID int64 // messages.id of the user message (for DB cleanup)
168+}
169+
151170 // ---------------------------------------------------------------------------
152171 // Model
153172 // ---------------------------------------------------------------------------
@@ -195,6 +214,12 @@ type Model struct {
195214 streamEntryStart int // Index in convEntries where streaming entries begin (-1 = none)
196215 streamWrapStart int // Number of cached wrapped lines before streaming entries
197216
217+ // Undo
218+ deltaTracker *delta.Tracker
219+ turnBoundaries []turnBoundary
220+ fileTracker FileReadResetter // for clearing read-tracking on undo
221+ tsIndex *treesitter.Index
222+
198223 // Editor state
199224 editorFilePath string // absolute path of the file currently shown in the editor
200225
@@ -210,7 +235,7 @@ type Model struct {
210235 }
211236
212237 // New creates a new TUI model.
213-func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID string, db *store.Cache, sessionID string, idx *treesitter.Index) Model {
238+func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID string, db *store.Cache, sessionID string, idx *treesitter.Index, dt *delta.Tracker, ft FileReadResetter) Model {
214239 sty := DefaultStyles()
215240 cursorStyle := lipgloss.NewStyle().Foreground(ColorHighlight)
216241
@@ -275,6 +300,10 @@ func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID str
275300 store: db,
276301 sessionID: sessionID,
277302
303+ deltaTracker: dt,
304+ fileTracker: ft,
305+ tsIndex: idx,
306+
278307 streamEntryStart: -1,
279308 hoverConvLine: -1,
280309 }
internal/tui/update.go+123−2
@@ -6,6 +6,7 @@ import (
66 "time"
77
88 tea "charm.land/bubbletea/v2"
9+ "github.com/rs/zerolog/log"
910 "github.com/xonecas/symb/internal/provider"
1011 )
1112
@@ -55,6 +56,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
5556 case UpdateToolsMsg:
5657 m.mcpTools = msg.Tools
5758 return m, nil
59+
60+ case undoMsg:
61+ return m.handleUndo(), nil
5862 }
5963
6064 // Always tick spinner
@@ -139,8 +143,33 @@ func (m *Model) handleKeyPress(msg tea.KeyPressMsg) (Model, tea.Cmd, bool) {
139143 func (m *Model) handleUserMsg(msg llmUserMsg) Model {
140144 now := time.Now()
141145 userMsg := provider.Message{Role: "user", Content: msg.content, CreatedAt: now}
146+
147+ historyIdx := len(m.history)
148+ convIdx := len(m.convEntries)
142149 m.history = append(m.history, userMsg)
143- m.saveMessage(userMsg)
150+
151+ // Save synchronously to get DB row ID for undo tracking.
152+ var dbMsgID int64
153+ if m.store != nil {
154+ id, err := m.store.SaveMessageSync(m.sessionID, messageToStore(userMsg))
155+ if err != nil {
156+ log.Warn().Err(err).Msg("failed to save user message; undo disabled for this turn")
157+ } else {
158+ dbMsgID = id
159+ }
160+ }
161+
162+ // Set delta tracker turn so file edits are linked.
163+ if m.deltaTracker != nil && dbMsgID > 0 {
164+ m.deltaTracker.BeginTurn(dbMsgID)
165+ }
166+
167+ m.turnBoundaries = append(m.turnBoundaries, turnBoundary{
168+ historyIdx: historyIdx,
169+ convIdx: convIdx,
170+ dbMsgID: dbMsgID,
171+ })
172+
144173 m.appendText(styledLines(msg.content, m.styles.Text)...)
145174 m.appendText("")
146175 sep := m.makeSeparator("0s", now.Format("15:04:05"))
@@ -189,9 +218,13 @@ func (m Model) handleLLMBatch(batch llmBatchMsg) (tea.Model, tea.Cmd) {
189218
190219 case llmDoneMsg:
191220 m.flushRebuild(needRebuild)
221+ // Replace previous turn's undo entry with a normal separator.
222+ m.demoteOldUndo()
192223 m.appendText("")
224+ // Append undo control instead of a plain separator for the latest turn.
225+ // Store the separator text in full so it can be restored on demote.
193226 sep := m.makeSeparator(msg.duration.Round(time.Second).String(), msg.timestamp)
194- m.appendText(sep)
227+ m.appendConv(m.makeUndoEntry(sep))
195228 return m, nil
196229 }
197230 }
@@ -301,3 +334,91 @@ func (m *Model) updateComponentSizes() {
301334 m.agentInput.SetWidth(m.layout.input.Dx() - 2) // padding for border
302335 m.agentInput.SetHeight(inputRows)
303336 }
337+
338+// demoteOldUndo finds the existing entryUndo in convEntries and demotes it
339+// to an entrySeparator (preserving the original display for potential
340+// re-promotion). Called before appending a new undo entry so only the
341+// latest turn shows the undo control.
342+func (m *Model) demoteOldUndo() {
343+ for i := len(m.convEntries) - 1; i >= 0; i-- {
344+ if m.convEntries[i].kind == entryUndo {
345+ m.convEntries[i].kind = entrySeparator
346+ // full field carries the original separator display text.
347+ m.convEntries[i].display = m.convEntries[i].full
348+ m.convLines = nil // invalidate cache
349+ return
350+ }
351+ }
352+}
353+
354+// handleUndo reverts the most recent turn: restores files, truncates history
355+// and convEntries, and cleans up the database.
356+func (m *Model) handleUndo() Model {
357+ if m.streaming || len(m.turnBoundaries) == 0 {
358+ return *m
359+ }
360+
361+ tb := m.turnBoundaries[len(m.turnBoundaries)-1]
362+ m.turnBoundaries = m.turnBoundaries[:len(m.turnBoundaries)-1]
363+
364+ // 1. Reverse filesystem changes.
365+ var undoErr error
366+ var restoredFiles []string
367+ if m.deltaTracker != nil && tb.dbMsgID > 0 {
368+ restoredFiles, undoErr = m.deltaTracker.Undo(m.sessionID, tb.dbMsgID)
369+ m.deltaTracker.DeleteTurn(m.sessionID, tb.dbMsgID)
370+ }
371+
372+ // 2. Truncate in-memory history and display.
373+ m.history = m.history[:tb.historyIdx]
374+ m.convEntries = m.convEntries[:tb.convIdx]
375+ m.convLines = nil // invalidate cache
376+
377+ // 2b. Show error after truncation so it's visible.
378+ if undoErr != nil {
379+ m.appendText("", m.styles.Error.Render("undo file restore failed: "+undoErr.Error()), "")
380+ }
381+
382+ // 3. Flush async saves then delete messages from DB.
383+ if m.store != nil && tb.dbMsgID > 0 {
384+ m.store.Flush()
385+ if err := m.store.DeleteMessagesFrom(m.sessionID, tb.dbMsgID); err != nil {
386+ log.Warn().Err(err).Msg("undo: failed to delete messages")
387+ }
388+ }
389+
390+ // 4. Clear file-read tracker (LLM will re-Read as needed).
391+ if m.fileTracker != nil {
392+ m.fileTracker.Reset()
393+ }
394+
395+ // 5. Update tree-sitter index for restored files only.
396+ if m.tsIndex != nil {
397+ for _, f := range restoredFiles {
398+ m.tsIndex.UpdateFile(f)
399+ }
400+ }
401+
402+ // 6. Promote previous turn's demoted separator back to undo, if any.
403+ if len(m.turnBoundaries) > 0 {
404+ for i := len(m.convEntries) - 1; i >= 0; i-- {
405+ if m.convEntries[i].kind == entrySeparator {
406+ // full carries the original separator display text.
407+ m.convEntries[i] = m.makeUndoEntry(m.convEntries[i].full)
408+ m.convLines = nil
409+ break
410+ }
411+ }
412+ }
413+
414+ // 7. Reset streaming state.
415+ m.streaming = false
416+ m.streamEntryStart = -1
417+ m.streamingReasoning = ""
418+ m.streamingContent = ""
419+
420+ // 8. Scroll to bottom.
421+ m.scrollOffset = 0
422+
423+ return *m
424+}