v0.5.9: session cleanup command

Add 'kode session cleanup <days>' to delete all sessions older than
the given number of days.

- Store.Cleanup(before time.Time) method scans sessions by UpdatedAt
- CLI handler with validation for non-negative integer days
- 4 new tests: basic cleanup, empty store, zero-days, idempotent
- Updated usage text and test coverage

Author: jkyberneees

cmd/kode/main.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 	"runtime/debug"
 	"strings"
+	"time"
 
 	"github.com/BackendStack21/kode"
 	"github.com/BackendStack21/kode/internal/config"
@@ -213,15 +214,15 @@ func printUsage() {
   kode run [flags] <task>
   kode run --session [flags] <task>
   kode continue [--id <id>] <task>
-  kode session <list|show [id]|trim <id> <n>|delete <id>>
+  kode session <list|show [id]|trim <id> <n>|delete <id>|cleanup <days>>
   kode init [--global | -g] [--force | -f]
   kode version
 
 Commands:
   run                 Execute a task with the agent loop
   run --session       Execute and save conversation as a session
   continue            Continue the most recent session (or by --id)
-  session             Manage sessions: list, show, delete
+  session             Manage sessions: list, show, delete, trim, cleanup
   init                Create a config file (default: ./kode.json)
   version             Print version and exit
 
@@ -871,8 +872,10 @@ func sessionCmd(args []string) error {
 		return deleteSession(store, args[1:])
 	case "trim":
 		return trimSession(store, args[1:])
+	case "cleanup":
+		return cleanupSessions(store, args[1:])
 	default:
-		return fmt.Errorf("unknown session command %q (use list, show, trim, delete)", args[0])
+		return fmt.Errorf("unknown session command %q (use list, show, trim, delete, cleanup)", args[0])
 	}
 }
 
@@ -1012,6 +1015,30 @@ func trimSession(store *session.Store, args []string) error {
 	return nil
 }
 
+// cleanupSessions deletes all sessions older than the given number of days.
+// Usage: kode session cleanup <days>
+func cleanupSessions(store *session.Store, args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("usage: kode session cleanup <days>")
+	}
+	var days int
+	if _, err := fmt.Sscanf(args[0], "%d", &days); err != nil || days < 0 {
+		return fmt.Errorf("invalid days %q — must be a non-negative integer", args[0])
+	}
+
+	before := time.Now().UTC().AddDate(0, 0, -days)
+	count, err := store.Cleanup(before)
+	if err != nil {
+		return fmt.Errorf("cleanup sessions: %w", err)
+	}
+	if count == 0 {
+		fmt.Println("No sessions to clean up.")
+	} else {
+		fmt.Printf("Cleaned up %d session(s) older than %d days.\n", count, days)
+	}
+	return nil
+}
+
 // countUserTurnsUpTo counts user messages up to (but not including) index n.
 func countUserTurnsUpTo(messages []llm.Message, n int) int {
 	count := 0

cmd/kode/main_test.go

@@ -226,6 +226,7 @@ func TestPrintUsage(t *testing.T) {
 		"kode continue",
 		"kode session",
 		"trim",
+		"cleanup",
 		"kode init",
 		"kode version",
 		"Commands:",

internal/session/session.go

@@ -228,6 +228,34 @@ func (s *Store) Delete(id string) error {
 	return err
 }
 
+// Cleanup deletes all sessions whose UpdatedAt is before the given time.
+// Returns the count of deleted sessions. Idempotent — nonexistent files
+// are skipped silently (os.Remove already handles this via Delete).
+func (s *Store) Cleanup(before time.Time) (int, error) {
+	entries, err := os.ReadDir(s.dir)
+	if err != nil {
+		return 0, fmt.Errorf("session: list: %w", err)
+	}
+
+	var deleted int
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".json") {
+			continue
+		}
+		sess, err := s.Load(idFromPath(e.Name()))
+		if err != nil {
+			continue // skip unreadable files
+		}
+		if sess.UpdatedAt.Before(before) {
+			if err := s.Delete(sess.ID); err != nil {
+				return deleted, fmt.Errorf("session: delete %q: %w", sess.ID, err)
+			}
+			deleted++
+		}
+	}
+	return deleted, nil
+}
+
 // ── Helpers ────────────────────────────────────────────────────────────
 
 // countUserTurns returns the number of user messages in a slice.

internal/session/session_test.go

@@ -4,6 +4,7 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/BackendStack21/kode/internal/llm"
 )
@@ -155,6 +156,94 @@ func TestStore_Delete(t *testing.T) {
 	}
 }
 
+func TestStore_Cleanup(t *testing.T) {
+	store := newTestStore(t)
+
+	// Create a "current" session
+	msgs := []llm.Message{{Role: "user", Content: "current"}}
+	current, err := store.Create(msgs, "m", "current")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create an "old" session by rewriting its UpdatedAt
+	msgs2 := []llm.Message{{Role: "user", Content: "old"}}
+	oldSess, err := store.Create(msgs2, "m", "old")
+	if err != nil {
+		t.Fatal(err)
+	}
+	oldSess.UpdatedAt = oldSess.UpdatedAt.AddDate(0, 0, -30) // 30 days ago
+	if err := store.Save(oldSess); err != nil {
+		t.Fatal(err)
+	}
+
+	// Cleanup sessions older than 7 days
+	deleted, err := store.Cleanup(time.Now().UTC().AddDate(0, 0, -7))
+	if err != nil {
+		t.Fatalf("Cleanup() error: %v", err)
+	}
+	if deleted != 1 {
+		t.Errorf("Cleanup() deleted %d, want 1", deleted)
+	}
+
+	// Current session should still exist
+	if _, err := store.Load(current.ID); err != nil {
+		t.Errorf("current session should survive cleanup: %v", err)
+	}
+
+	// Old session should be gone
+	if _, err := store.Load(oldSess.ID); err == nil {
+		t.Error("old session should have been deleted")
+	}
+}
+
+func TestStore_Cleanup_EmptyStore(t *testing.T) {
+	store := newTestStore(t)
+	deleted, err := store.Cleanup(time.Now().UTC())
+	if err != nil {
+		t.Fatalf("Cleanup() on empty store: %v", err)
+	}
+	if deleted != 0 {
+		t.Errorf("Cleanup() deleted %d, want 0", deleted)
+	}
+}
+
+func TestStore_Cleanup_ZeroDays(t *testing.T) {
+	store := newTestStore(t)
+
+	msgs := []llm.Message{{Role: "user", Content: "anything"}}
+	sess, err := store.Create(msgs, "m", "test")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// cleanup with 0 days = delete everything (all sessions are older than "right now" since UpdatedAt is from Create)
+	deleted, err := store.Cleanup(time.Now().UTC())
+	if err != nil {
+		t.Fatalf("Cleanup() error: %v", err)
+	}
+	if deleted != 1 {
+		t.Errorf("Cleanup() deleted %d, want 1", deleted)
+	}
+	if _, err := store.Load(sess.ID); err == nil {
+		t.Error("session should have been deleted")
+	}
+}
+
+func TestStore_Cleanup_Idempotent(t *testing.T) {
+	store := newTestStore(t)
+
+	// Cleanup empty store twice — should not error
+	_, err := store.Cleanup(time.Now().UTC())
+	if err != nil {
+		t.Fatalf("first Cleanup: %v", err)
+	}
+	_, err = store.Cleanup(time.Now().UTC())
+	if err != nil {
+		t.Fatalf("second Cleanup (idempotent): %v", err)
+	}
+}
+
 func TestGenerateID(t *testing.T) {
 	id := generateID()
 	if !strings.Contains(id, "-") {