Add files using upload-large-folder tool

projects/ui/crush/internal/db/db.go

@@ -0,0 +1,278 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+)
+
+type DBTX interface {
+	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+	PrepareContext(context.Context, string) (*sql.Stmt, error)
+	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
+	q := Queries{db: db}
+	var err error
+	if q.createFileStmt, err = db.PrepareContext(ctx, createFile); err != nil {
+		return nil, fmt.Errorf("error preparing query CreateFile: %w", err)
+	}
+	if q.createMessageStmt, err = db.PrepareContext(ctx, createMessage); err != nil {
+		return nil, fmt.Errorf("error preparing query CreateMessage: %w", err)
+	}
+	if q.createSessionStmt, err = db.PrepareContext(ctx, createSession); err != nil {
+		return nil, fmt.Errorf("error preparing query CreateSession: %w", err)
+	}
+	if q.deleteFileStmt, err = db.PrepareContext(ctx, deleteFile); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteFile: %w", err)
+	}
+	if q.deleteMessageStmt, err = db.PrepareContext(ctx, deleteMessage); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteMessage: %w", err)
+	}
+	if q.deleteSessionStmt, err = db.PrepareContext(ctx, deleteSession); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteSession: %w", err)
+	}
+	if q.deleteSessionFilesStmt, err = db.PrepareContext(ctx, deleteSessionFiles); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteSessionFiles: %w", err)
+	}
+	if q.deleteSessionMessagesStmt, err = db.PrepareContext(ctx, deleteSessionMessages); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteSessionMessages: %w", err)
+	}
+	if q.getFileStmt, err = db.PrepareContext(ctx, getFile); err != nil {
+		return nil, fmt.Errorf("error preparing query GetFile: %w", err)
+	}
+	if q.getFileByPathAndSessionStmt, err = db.PrepareContext(ctx, getFileByPathAndSession); err != nil {
+		return nil, fmt.Errorf("error preparing query GetFileByPathAndSession: %w", err)
+	}
+	if q.getMessageStmt, err = db.PrepareContext(ctx, getMessage); err != nil {
+		return nil, fmt.Errorf("error preparing query GetMessage: %w", err)
+	}
+	if q.getSessionByIDStmt, err = db.PrepareContext(ctx, getSessionByID); err != nil {
+		return nil, fmt.Errorf("error preparing query GetSessionByID: %w", err)
+	}
+	if q.listFilesByPathStmt, err = db.PrepareContext(ctx, listFilesByPath); err != nil {
+		return nil, fmt.Errorf("error preparing query ListFilesByPath: %w", err)
+	}
+	if q.listFilesBySessionStmt, err = db.PrepareContext(ctx, listFilesBySession); err != nil {
+		return nil, fmt.Errorf("error preparing query ListFilesBySession: %w", err)
+	}
+	if q.listLatestSessionFilesStmt, err = db.PrepareContext(ctx, listLatestSessionFiles); err != nil {
+		return nil, fmt.Errorf("error preparing query ListLatestSessionFiles: %w", err)
+	}
+	if q.listMessagesBySessionStmt, err = db.PrepareContext(ctx, listMessagesBySession); err != nil {
+		return nil, fmt.Errorf("error preparing query ListMessagesBySession: %w", err)
+	}
+	if q.listNewFilesStmt, err = db.PrepareContext(ctx, listNewFiles); err != nil {
+		return nil, fmt.Errorf("error preparing query ListNewFiles: %w", err)
+	}
+	if q.listSessionsStmt, err = db.PrepareContext(ctx, listSessions); err != nil {
+		return nil, fmt.Errorf("error preparing query ListSessions: %w", err)
+	}
+	if q.updateMessageStmt, err = db.PrepareContext(ctx, updateMessage); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateMessage: %w", err)
+	}
+	if q.updateSessionStmt, err = db.PrepareContext(ctx, updateSession); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateSession: %w", err)
+	}
+	return &q, nil
+}
+
+func (q *Queries) Close() error {
+	var err error
+	if q.createFileStmt != nil {
+		if cerr := q.createFileStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing createFileStmt: %w", cerr)
+		}
+	}
+	if q.createMessageStmt != nil {
+		if cerr := q.createMessageStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing createMessageStmt: %w", cerr)
+		}
+	}
+	if q.createSessionStmt != nil {
+		if cerr := q.createSessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing createSessionStmt: %w", cerr)
+		}
+	}
+	if q.deleteFileStmt != nil {
+		if cerr := q.deleteFileStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteFileStmt: %w", cerr)
+		}
+	}
+	if q.deleteMessageStmt != nil {
+		if cerr := q.deleteMessageStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteMessageStmt: %w", cerr)
+		}
+	}
+	if q.deleteSessionStmt != nil {
+		if cerr := q.deleteSessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteSessionStmt: %w", cerr)
+		}
+	}
+	if q.deleteSessionFilesStmt != nil {
+		if cerr := q.deleteSessionFilesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteSessionFilesStmt: %w", cerr)
+		}
+	}
+	if q.deleteSessionMessagesStmt != nil {
+		if cerr := q.deleteSessionMessagesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteSessionMessagesStmt: %w", cerr)
+		}
+	}
+	if q.getFileStmt != nil {
+		if cerr := q.getFileStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getFileStmt: %w", cerr)
+		}
+	}
+	if q.getFileByPathAndSessionStmt != nil {
+		if cerr := q.getFileByPathAndSessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getFileByPathAndSessionStmt: %w", cerr)
+		}
+	}
+	if q.getMessageStmt != nil {
+		if cerr := q.getMessageStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getMessageStmt: %w", cerr)
+		}
+	}
+	if q.getSessionByIDStmt != nil {
+		if cerr := q.getSessionByIDStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getSessionByIDStmt: %w", cerr)
+		}
+	}
+	if q.listFilesByPathStmt != nil {
+		if cerr := q.listFilesByPathStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listFilesByPathStmt: %w", cerr)
+		}
+	}
+	if q.listFilesBySessionStmt != nil {
+		if cerr := q.listFilesBySessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listFilesBySessionStmt: %w", cerr)
+		}
+	}
+	if q.listLatestSessionFilesStmt != nil {
+		if cerr := q.listLatestSessionFilesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listLatestSessionFilesStmt: %w", cerr)
+		}
+	}
+	if q.listMessagesBySessionStmt != nil {
+		if cerr := q.listMessagesBySessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listMessagesBySessionStmt: %w", cerr)
+		}
+	}
+	if q.listNewFilesStmt != nil {
+		if cerr := q.listNewFilesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listNewFilesStmt: %w", cerr)
+		}
+	}
+	if q.listSessionsStmt != nil {
+		if cerr := q.listSessionsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listSessionsStmt: %w", cerr)
+		}
+	}
+	if q.updateMessageStmt != nil {
+		if cerr := q.updateMessageStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateMessageStmt: %w", cerr)
+		}
+	}
+	if q.updateSessionStmt != nil {
+		if cerr := q.updateSessionStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateSessionStmt: %w", cerr)
+		}
+	}
+	return err
+}
+
+func (q *Queries) exec(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (sql.Result, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).ExecContext(ctx, args...)
+	case stmt != nil:
+		return stmt.ExecContext(ctx, args...)
+	default:
+		return q.db.ExecContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) query(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (*sql.Rows, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryContext(ctx, args...)
+	default:
+		return q.db.QueryContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) *sql.Row {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryRowContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryRowContext(ctx, args...)
+	default:
+		return q.db.QueryRowContext(ctx, query, args...)
+	}
+}
+
+type Queries struct {
+	db                          DBTX
+	tx                          *sql.Tx
+	createFileStmt              *sql.Stmt
+	createMessageStmt           *sql.Stmt
+	createSessionStmt           *sql.Stmt
+	deleteFileStmt              *sql.Stmt
+	deleteMessageStmt           *sql.Stmt
+	deleteSessionStmt           *sql.Stmt
+	deleteSessionFilesStmt      *sql.Stmt
+	deleteSessionMessagesStmt   *sql.Stmt
+	getFileStmt                 *sql.Stmt
+	getFileByPathAndSessionStmt *sql.Stmt
+	getMessageStmt              *sql.Stmt
+	getSessionByIDStmt          *sql.Stmt
+	listFilesByPathStmt         *sql.Stmt
+	listFilesBySessionStmt      *sql.Stmt
+	listLatestSessionFilesStmt  *sql.Stmt
+	listMessagesBySessionStmt   *sql.Stmt
+	listNewFilesStmt            *sql.Stmt
+	listSessionsStmt            *sql.Stmt
+	updateMessageStmt           *sql.Stmt
+	updateSessionStmt           *sql.Stmt
+}
+
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db:                          tx,
+		tx:                          tx,
+		createFileStmt:              q.createFileStmt,
+		createMessageStmt:           q.createMessageStmt,
+		createSessionStmt:           q.createSessionStmt,
+		deleteFileStmt:              q.deleteFileStmt,
+		deleteMessageStmt:           q.deleteMessageStmt,
+		deleteSessionStmt:           q.deleteSessionStmt,
+		deleteSessionFilesStmt:      q.deleteSessionFilesStmt,
+		deleteSessionMessagesStmt:   q.deleteSessionMessagesStmt,
+		getFileStmt:                 q.getFileStmt,
+		getFileByPathAndSessionStmt: q.getFileByPathAndSessionStmt,
+		getMessageStmt:              q.getMessageStmt,
+		getSessionByIDStmt:          q.getSessionByIDStmt,
+		listFilesByPathStmt:         q.listFilesByPathStmt,
+		listFilesBySessionStmt:      q.listFilesBySessionStmt,
+		listLatestSessionFilesStmt:  q.listLatestSessionFilesStmt,
+		listMessagesBySessionStmt:   q.listMessagesBySessionStmt,
+		listNewFilesStmt:            q.listNewFilesStmt,
+		listSessionsStmt:            q.listSessionsStmt,
+		updateMessageStmt:           q.updateMessageStmt,
+		updateSessionStmt:           q.updateSessionStmt,
+	}
+}

projects/ui/crush/internal/db/embed.go

@@ -0,0 +1,6 @@
+package db
+
+import "embed"
+
+//go:embed migrations/*.sql
+var FS embed.FS

projects/ui/crush/internal/db/files.sql.go

@@ -0,0 +1,280 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+// source: files.sql
+
+package db
+
+import (
+	"context"
+)
+
+const createFile = `-- name: CreateFile :one
+INSERT INTO files (
+    id,
+    session_id,
+    path,
+    content,
+    version,
+    created_at,
+    updated_at
+) VALUES (
+    ?, ?, ?, ?, ?, strftime('%s', 'now'), strftime('%s', 'now')
+)
+RETURNING id, session_id, path, content, version, created_at, updated_at
+`
+
+type CreateFileParams struct {
+	ID        string `json:"id"`
+	SessionID string `json:"session_id"`
+	Path      string `json:"path"`
+	Content   string `json:"content"`
+	Version   int64  `json:"version"`
+}
+
+func (q *Queries) CreateFile(ctx context.Context, arg CreateFileParams) (File, error) {
+	row := q.queryRow(ctx, q.createFileStmt, createFile,
+		arg.ID,
+		arg.SessionID,
+		arg.Path,
+		arg.Content,
+		arg.Version,
+	)
+	var i File
+	err := row.Scan(
+		&i.ID,
+		&i.SessionID,
+		&i.Path,
+		&i.Content,
+		&i.Version,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const deleteFile = `-- name: DeleteFile :exec
+DELETE FROM files
+WHERE id = ?
+`
+
+func (q *Queries) DeleteFile(ctx context.Context, id string) error {
+	_, err := q.exec(ctx, q.deleteFileStmt, deleteFile, id)
+	return err
+}
+
+const deleteSessionFiles = `-- name: DeleteSessionFiles :exec
+DELETE FROM files
+WHERE session_id = ?
+`
+
+func (q *Queries) DeleteSessionFiles(ctx context.Context, sessionID string) error {
+	_, err := q.exec(ctx, q.deleteSessionFilesStmt, deleteSessionFiles, sessionID)
+	return err
+}
+
+const getFile = `-- name: GetFile :one
+SELECT id, session_id, path, content, version, created_at, updated_at
+FROM files
+WHERE id = ? LIMIT 1
+`
+
+func (q *Queries) GetFile(ctx context.Context, id string) (File, error) {
+	row := q.queryRow(ctx, q.getFileStmt, getFile, id)
+	var i File
+	err := row.Scan(
+		&i.ID,
+		&i.SessionID,
+		&i.Path,
+		&i.Content,
+		&i.Version,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getFileByPathAndSession = `-- name: GetFileByPathAndSession :one
+SELECT id, session_id, path, content, version, created_at, updated_at
+FROM files
+WHERE path = ? AND session_id = ?
+ORDER BY version DESC, created_at DESC
+LIMIT 1
+`
+
+type GetFileByPathAndSessionParams struct {
+	Path      string `json:"path"`
+	SessionID string `json:"session_id"`
+}
+
+func (q *Queries) GetFileByPathAndSession(ctx context.Context, arg GetFileByPathAndSessionParams) (File, error) {
+	row := q.queryRow(ctx, q.getFileByPathAndSessionStmt, getFileByPathAndSession, arg.Path, arg.SessionID)
+	var i File
+	err := row.Scan(
+		&i.ID,
+		&i.SessionID,
+		&i.Path,
+		&i.Content,
+		&i.Version,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const listFilesByPath = `-- name: ListFilesByPath :many
+SELECT id, session_id, path, content, version, created_at, updated_at
+FROM files
+WHERE path = ?
+ORDER BY version DESC, created_at DESC
+`
+
+func (q *Queries) ListFilesByPath(ctx context.Context, path string) ([]File, error) {
+	rows, err := q.query(ctx, q.listFilesByPathStmt, listFilesByPath, path)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []File{}
+	for rows.Next() {
+		var i File
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.Path,
+			&i.Content,
+			&i.Version,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listFilesBySession = `-- name: ListFilesBySession :many
+SELECT id, session_id, path, content, version, created_at, updated_at
+FROM files
+WHERE session_id = ?
+ORDER BY version ASC, created_at ASC
+`
+
+func (q *Queries) ListFilesBySession(ctx context.Context, sessionID string) ([]File, error) {
+	rows, err := q.query(ctx, q.listFilesBySessionStmt, listFilesBySession, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []File{}
+	for rows.Next() {
+		var i File
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.Path,
+			&i.Content,
+			&i.Version,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listLatestSessionFiles = `-- name: ListLatestSessionFiles :many
+SELECT f.id, f.session_id, f.path, f.content, f.version, f.created_at, f.updated_at
+FROM files f
+INNER JOIN (
+    SELECT path, MAX(version) as max_version, MAX(created_at) as max_created_at
+    FROM files
+    GROUP BY path
+) latest ON f.path = latest.path AND f.version = latest.max_version AND f.created_at = latest.max_created_at
+WHERE f.session_id = ?
+ORDER BY f.path
+`
+
+func (q *Queries) ListLatestSessionFiles(ctx context.Context, sessionID string) ([]File, error) {
+	rows, err := q.query(ctx, q.listLatestSessionFilesStmt, listLatestSessionFiles, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []File{}
+	for rows.Next() {
+		var i File
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.Path,
+			&i.Content,
+			&i.Version,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listNewFiles = `-- name: ListNewFiles :many
+SELECT id, session_id, path, content, version, created_at, updated_at
+FROM files
+WHERE is_new = 1
+ORDER BY version DESC, created_at DESC
+`
+
+func (q *Queries) ListNewFiles(ctx context.Context) ([]File, error) {
+	rows, err := q.query(ctx, q.listNewFilesStmt, listNewFiles)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []File{}
+	for rows.Next() {
+		var i File
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.Path,
+			&i.Content,
+			&i.Version,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}

projects/ui/crush/internal/db/messages.sql.go

@@ -0,0 +1,163 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+// source: messages.sql
+
+package db
+
+import (
+	"context"
+	"database/sql"
+)
+
+const createMessage = `-- name: CreateMessage :one
+INSERT INTO messages (
+    id,
+    session_id,
+    role,
+    parts,
+    model,
+    provider,
+    created_at,
+    updated_at
+) VALUES (
+    ?, ?, ?, ?, ?, ?, strftime('%s', 'now'), strftime('%s', 'now')
+)
+RETURNING id, session_id, role, parts, model, created_at, updated_at, finished_at, provider
+`
+
+type CreateMessageParams struct {
+	ID        string         `json:"id"`
+	SessionID string         `json:"session_id"`
+	Role      string         `json:"role"`
+	Parts     string         `json:"parts"`
+	Model     sql.NullString `json:"model"`
+	Provider  sql.NullString `json:"provider"`
+}
+
+func (q *Queries) CreateMessage(ctx context.Context, arg CreateMessageParams) (Message, error) {
+	row := q.queryRow(ctx, q.createMessageStmt, createMessage,
+		arg.ID,
+		arg.SessionID,
+		arg.Role,
+		arg.Parts,
+		arg.Model,
+		arg.Provider,
+	)
+	var i Message
+	err := row.Scan(
+		&i.ID,
+		&i.SessionID,
+		&i.Role,
+		&i.Parts,
+		&i.Model,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.FinishedAt,
+		&i.Provider,
+	)
+	return i, err
+}
+
+const deleteMessage = `-- name: DeleteMessage :exec
+DELETE FROM messages
+WHERE id = ?
+`
+
+func (q *Queries) DeleteMessage(ctx context.Context, id string) error {
+	_, err := q.exec(ctx, q.deleteMessageStmt, deleteMessage, id)
+	return err
+}
+
+const deleteSessionMessages = `-- name: DeleteSessionMessages :exec
+DELETE FROM messages
+WHERE session_id = ?
+`
+
+func (q *Queries) DeleteSessionMessages(ctx context.Context, sessionID string) error {
+	_, err := q.exec(ctx, q.deleteSessionMessagesStmt, deleteSessionMessages, sessionID)
+	return err
+}
+
+const getMessage = `-- name: GetMessage :one
+SELECT id, session_id, role, parts, model, created_at, updated_at, finished_at, provider
+FROM messages
+WHERE id = ? LIMIT 1
+`
+
+func (q *Queries) GetMessage(ctx context.Context, id string) (Message, error) {
+	row := q.queryRow(ctx, q.getMessageStmt, getMessage, id)
+	var i Message
+	err := row.Scan(
+		&i.ID,
+		&i.SessionID,
+		&i.Role,
+		&i.Parts,
+		&i.Model,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.FinishedAt,
+		&i.Provider,
+	)
+	return i, err
+}
+
+const listMessagesBySession = `-- name: ListMessagesBySession :many
+SELECT id, session_id, role, parts, model, created_at, updated_at, finished_at, provider
+FROM messages
+WHERE session_id = ?
+ORDER BY created_at ASC
+`
+
+func (q *Queries) ListMessagesBySession(ctx context.Context, sessionID string) ([]Message, error) {
+	rows, err := q.query(ctx, q.listMessagesBySessionStmt, listMessagesBySession, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Message{}
+	for rows.Next() {
+		var i Message
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.Role,
+			&i.Parts,
+			&i.Model,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.FinishedAt,
+			&i.Provider,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateMessage = `-- name: UpdateMessage :exec
+UPDATE messages
+SET
+    parts = ?,
+    finished_at = ?,
+    updated_at = strftime('%s', 'now')
+WHERE id = ?
+`
+
+type UpdateMessageParams struct {
+	Parts      string        `json:"parts"`
+	FinishedAt sql.NullInt64 `json:"finished_at"`
+	ID         string        `json:"id"`
+}
+
+func (q *Queries) UpdateMessage(ctx context.Context, arg UpdateMessageParams) error {
+	_, err := q.exec(ctx, q.updateMessageStmt, updateMessage, arg.Parts, arg.FinishedAt, arg.ID)
+	return err
+}

projects/ui/crush/internal/db/models.go

@@ -0,0 +1,44 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+
+package db
+
+import (
+	"database/sql"
+)
+
+type File struct {
+	ID        string `json:"id"`
+	SessionID string `json:"session_id"`
+	Path      string `json:"path"`
+	Content   string `json:"content"`
+	Version   int64  `json:"version"`
+	CreatedAt int64  `json:"created_at"`
+	UpdatedAt int64  `json:"updated_at"`
+}
+
+type Message struct {
+	ID         string         `json:"id"`
+	SessionID  string         `json:"session_id"`
+	Role       string         `json:"role"`
+	Parts      string         `json:"parts"`
+	Model      sql.NullString `json:"model"`
+	CreatedAt  int64          `json:"created_at"`
+	UpdatedAt  int64          `json:"updated_at"`
+	FinishedAt sql.NullInt64  `json:"finished_at"`
+	Provider   sql.NullString `json:"provider"`
+}
+
+type Session struct {
+	ID               string         `json:"id"`
+	ParentSessionID  sql.NullString `json:"parent_session_id"`
+	Title            string         `json:"title"`
+	MessageCount     int64          `json:"message_count"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	Cost             float64        `json:"cost"`
+	UpdatedAt        int64          `json:"updated_at"`
+	CreatedAt        int64          `json:"created_at"`
+	SummaryMessageID sql.NullString `json:"summary_message_id"`
+}

projects/ui/crush/internal/db/querier.go

@@ -0,0 +1,34 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+
+package db
+
+import (
+	"context"
+)
+
+type Querier interface {
+	CreateFile(ctx context.Context, arg CreateFileParams) (File, error)
+	CreateMessage(ctx context.Context, arg CreateMessageParams) (Message, error)
+	CreateSession(ctx context.Context, arg CreateSessionParams) (Session, error)
+	DeleteFile(ctx context.Context, id string) error
+	DeleteMessage(ctx context.Context, id string) error
+	DeleteSession(ctx context.Context, id string) error
+	DeleteSessionFiles(ctx context.Context, sessionID string) error
+	DeleteSessionMessages(ctx context.Context, sessionID string) error
+	GetFile(ctx context.Context, id string) (File, error)
+	GetFileByPathAndSession(ctx context.Context, arg GetFileByPathAndSessionParams) (File, error)
+	GetMessage(ctx context.Context, id string) (Message, error)
+	GetSessionByID(ctx context.Context, id string) (Session, error)
+	ListFilesByPath(ctx context.Context, path string) ([]File, error)
+	ListFilesBySession(ctx context.Context, sessionID string) ([]File, error)
+	ListLatestSessionFiles(ctx context.Context, sessionID string) ([]File, error)
+	ListMessagesBySession(ctx context.Context, sessionID string) ([]Message, error)
+	ListNewFiles(ctx context.Context) ([]File, error)
+	ListSessions(ctx context.Context) ([]Session, error)
+	UpdateMessage(ctx context.Context, arg UpdateMessageParams) error
+	UpdateSession(ctx context.Context, arg UpdateSessionParams) (Session, error)
+}
+
+var _ Querier = (*Queries)(nil)

projects/ui/crush/internal/db/sessions.sql.go

@@ -0,0 +1,194 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.29.0
+// source: sessions.sql
+
+package db
+
+import (
+	"context"
+	"database/sql"
+)
+
+const createSession = `-- name: CreateSession :one
+INSERT INTO sessions (
+    id,
+    parent_session_id,
+    title,
+    message_count,
+    prompt_tokens,
+    completion_tokens,
+    cost,
+    summary_message_id,
+    updated_at,
+    created_at
+) VALUES (
+    ?,
+    ?,
+    ?,
+    ?,
+    ?,
+    ?,
+    ?,
+    null,
+    strftime('%s', 'now'),
+    strftime('%s', 'now')
+) RETURNING id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, updated_at, created_at, summary_message_id
+`
+
+type CreateSessionParams struct {
+	ID               string         `json:"id"`
+	ParentSessionID  sql.NullString `json:"parent_session_id"`
+	Title            string         `json:"title"`
+	MessageCount     int64          `json:"message_count"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	Cost             float64        `json:"cost"`
+}
+
+func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) (Session, error) {
+	row := q.queryRow(ctx, q.createSessionStmt, createSession,
+		arg.ID,
+		arg.ParentSessionID,
+		arg.Title,
+		arg.MessageCount,
+		arg.PromptTokens,
+		arg.CompletionTokens,
+		arg.Cost,
+	)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.ParentSessionID,
+		&i.Title,
+		&i.MessageCount,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.Cost,
+		&i.UpdatedAt,
+		&i.CreatedAt,
+		&i.SummaryMessageID,
+	)
+	return i, err
+}
+
+const deleteSession = `-- name: DeleteSession :exec
+DELETE FROM sessions
+WHERE id = ?
+`
+
+func (q *Queries) DeleteSession(ctx context.Context, id string) error {
+	_, err := q.exec(ctx, q.deleteSessionStmt, deleteSession, id)
+	return err
+}
+
+const getSessionByID = `-- name: GetSessionByID :one
+SELECT id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, updated_at, created_at, summary_message_id
+FROM sessions
+WHERE id = ? LIMIT 1
+`
+
+func (q *Queries) GetSessionByID(ctx context.Context, id string) (Session, error) {
+	row := q.queryRow(ctx, q.getSessionByIDStmt, getSessionByID, id)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.ParentSessionID,
+		&i.Title,
+		&i.MessageCount,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.Cost,
+		&i.UpdatedAt,
+		&i.CreatedAt,
+		&i.SummaryMessageID,
+	)
+	return i, err
+}
+
+const listSessions = `-- name: ListSessions :many
+SELECT id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, updated_at, created_at, summary_message_id
+FROM sessions
+WHERE parent_session_id is NULL
+ORDER BY created_at DESC
+`
+
+func (q *Queries) ListSessions(ctx context.Context) ([]Session, error) {
+	rows, err := q.query(ctx, q.listSessionsStmt, listSessions)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Session{}
+	for rows.Next() {
+		var i Session
+		if err := rows.Scan(
+			&i.ID,
+			&i.ParentSessionID,
+			&i.Title,
+			&i.MessageCount,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.Cost,
+			&i.UpdatedAt,
+			&i.CreatedAt,
+			&i.SummaryMessageID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateSession = `-- name: UpdateSession :one
+UPDATE sessions
+SET
+    title = ?,
+    prompt_tokens = ?,
+    completion_tokens = ?,
+    summary_message_id = ?,
+    cost = ?
+WHERE id = ?
+RETURNING id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, updated_at, created_at, summary_message_id
+`
+
+type UpdateSessionParams struct {
+	Title            string         `json:"title"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	SummaryMessageID sql.NullString `json:"summary_message_id"`
+	Cost             float64        `json:"cost"`
+	ID               string         `json:"id"`
+}
+
+func (q *Queries) UpdateSession(ctx context.Context, arg UpdateSessionParams) (Session, error) {
+	row := q.queryRow(ctx, q.updateSessionStmt, updateSession,
+		arg.Title,
+		arg.PromptTokens,
+		arg.CompletionTokens,
+		arg.SummaryMessageID,
+		arg.Cost,
+		arg.ID,
+	)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.ParentSessionID,
+		&i.Title,
+		&i.MessageCount,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.Cost,
+		&i.UpdatedAt,
+		&i.CreatedAt,
+		&i.SummaryMessageID,
+	)
+	return i, err
+}

projects/ui/crush/internal/diff/diff.go

@@ -0,0 +1,29 @@
+package diff
+
+import (
+	"strings"
+
+	"github.com/aymanbagabas/go-udiff"
+)
+
+// GenerateDiff creates a unified diff from two file contents
+func GenerateDiff(beforeContent, afterContent, fileName string) (string, int, int) {
+	fileName = strings.TrimPrefix(fileName, "/")
+
+	var (
+		unified   = udiff.Unified("a/"+fileName, "b/"+fileName, beforeContent, afterContent)
+		additions = 0
+		removals  = 0
+	)
+
+	lines := strings.SplitSeq(unified, "\n")
+	for line := range lines {
+		if strings.HasPrefix(line, "+") && !strings.HasPrefix(line, "+++") {
+			additions++
+		} else if strings.HasPrefix(line, "-") && !strings.HasPrefix(line, "---") {
+			removals++
+		}
+	}
+
+	return unified, additions, removals
+}

projects/ui/crush/internal/env/env.go

@@ -0,0 +1,58 @@
+package env
+
+import "os"
+
+type Env interface {
+	Get(key string) string
+	Env() []string
+}
+
+type osEnv struct{}
+
+// Get implements Env.
+func (o *osEnv) Get(key string) string {
+	return os.Getenv(key)
+}
+
+func (o *osEnv) Env() []string {
+	env := os.Environ()
+	if len(env) == 0 {
+		return nil
+	}
+	return env
+}
+
+func New() Env {
+	return &osEnv{}
+}
+
+type mapEnv struct {
+	m map[string]string
+}
+
+// Get implements Env.
+func (m *mapEnv) Get(key string) string {
+	if value, ok := m.m[key]; ok {
+		return value
+	}
+	return ""
+}
+
+// Env implements Env.
+func (m *mapEnv) Env() []string {
+	if len(m.m) == 0 {
+		return nil
+	}
+	env := make([]string, 0, len(m.m))
+	for k, v := range m.m {
+		env = append(env, k+"="+v)
+	}
+	return env
+}
+
+func NewFromMap(m map[string]string) Env {
+	if m == nil {
+		m = make(map[string]string)
+	}
+	return &mapEnv{m: m}
+}

projects/ui/crush/internal/env/env_test.go

@@ -0,0 +1,140 @@
+package env
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOsEnv_Get(t *testing.T) {
+	env := New()
+
+	// Test getting an existing environment variable
+	t.Setenv("TEST_VAR", "test_value")
+
+	value := env.Get("TEST_VAR")
+	require.Equal(t, "test_value", value)
+
+	// Test getting a non-existent environment variable
+	value = env.Get("NON_EXISTENT_VAR")
+	require.Equal(t, "", value)
+}
+
+func TestOsEnv_Env(t *testing.T) {
+	env := New()
+
+	envVars := env.Env()
+
+	// Environment should not be empty in normal circumstances
+	require.NotNil(t, envVars)
+	require.Greater(t, len(envVars), 0)
+
+	// Each environment variable should be in key=value format
+	for _, envVar := range envVars {
+		require.Contains(t, envVar, "=")
+	}
+}
+
+func TestNewFromMap(t *testing.T) {
+	testMap := map[string]string{
+		"KEY1": "value1",
+		"KEY2": "value2",
+	}
+
+	env := NewFromMap(testMap)
+	require.NotNil(t, env)
+	require.IsType(t, &mapEnv{}, env)
+}
+
+func TestMapEnv_Get(t *testing.T) {
+	testMap := map[string]string{
+		"KEY1": "value1",
+		"KEY2": "value2",
+	}
+
+	env := NewFromMap(testMap)
+
+	// Test getting existing keys
+	require.Equal(t, "value1", env.Get("KEY1"))
+	require.Equal(t, "value2", env.Get("KEY2"))
+
+	// Test getting non-existent key
+	require.Equal(t, "", env.Get("NON_EXISTENT"))
+}
+
+func TestMapEnv_Env(t *testing.T) {
+	t.Run("with values", func(t *testing.T) {
+		testMap := map[string]string{
+			"KEY1": "value1",
+			"KEY2": "value2",
+		}
+
+		env := NewFromMap(testMap)
+		envVars := env.Env()
+
+		require.Len(t, envVars, 2)
+
+		// Convert to map for easier testing (order is not guaranteed)
+		envMap := make(map[string]string)
+		for _, envVar := range envVars {
+			parts := strings.SplitN(envVar, "=", 2)
+			require.Len(t, parts, 2)
+			envMap[parts[0]] = parts[1]
+		}
+
+		require.Equal(t, "value1", envMap["KEY1"])
+		require.Equal(t, "value2", envMap["KEY2"])
+	})
+
+	t.Run("empty map", func(t *testing.T) {
+		env := NewFromMap(map[string]string{})
+		envVars := env.Env()
+		require.Nil(t, envVars)
+	})
+
+	t.Run("nil map", func(t *testing.T) {
+		env := NewFromMap(nil)
+		envVars := env.Env()
+		require.Nil(t, envVars)
+	})
+}
+
+func TestMapEnv_GetEmptyValue(t *testing.T) {
+	testMap := map[string]string{
+		"EMPTY_KEY":  "",
+		"NORMAL_KEY": "value",
+	}
+
+	env := NewFromMap(testMap)
+
+	// Test that empty values are returned correctly
+	require.Equal(t, "", env.Get("EMPTY_KEY"))
+	require.Equal(t, "value", env.Get("NORMAL_KEY"))
+}
+
+func TestMapEnv_EnvFormat(t *testing.T) {
+	testMap := map[string]string{
+		"KEY_WITH_EQUALS": "value=with=equals",
+		"KEY_WITH_SPACES": "value with spaces",
+	}
+
+	env := NewFromMap(testMap)
+	envVars := env.Env()
+
+	require.Len(t, envVars, 2)
+
+	// Check that the format is correct even with special characters
+	found := make(map[string]bool)
+	for _, envVar := range envVars {
+		if envVar == "KEY_WITH_EQUALS=value=with=equals" {
+			found["equals"] = true
+		}
+		if envVar == "KEY_WITH_SPACES=value with spaces" {
+			found["spaces"] = true
+		}
+	}
+
+	require.True(t, found["equals"], "Should handle values with equals signs")
+	require.True(t, found["spaces"], "Should handle values with spaces")
+}

projects/ui/crush/internal/format/spinner.go

@@ -0,0 +1,88 @@
+package format
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+
+	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/crush/internal/tui/components/anim"
+	"github.com/charmbracelet/crush/internal/tui/styles"
+	"github.com/charmbracelet/x/ansi"
+)
+
+// Spinner wraps the bubbles spinner for non-interactive mode
+type Spinner struct {
+	done chan struct{}
+	prog *tea.Program
+}
+
+type model struct {
+	cancel context.CancelFunc
+	anim   *anim.Anim
+}
+
+func (m model) Init() tea.Cmd { return m.anim.Init() }
+func (m model) View() string  { return m.anim.View() }
+
+// Update implements tea.Model.
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyPressMsg:
+		switch msg.String() {
+		case "ctrl+c", "esc":
+			m.cancel()
+			return m, tea.Quit
+		}
+	}
+	mm, cmd := m.anim.Update(msg)
+	m.anim = mm.(*anim.Anim)
+	return m, cmd
+}
+
+// NewSpinner creates a new spinner with the given message
+func NewSpinner(ctx context.Context, cancel context.CancelFunc, message string) *Spinner {
+	t := styles.CurrentTheme()
+	model := model{
+		anim: anim.New(anim.Settings{
+			Size:        10,
+			Label:       message,
+			LabelColor:  t.FgBase,
+			GradColorA:  t.Primary,
+			GradColorB:  t.Secondary,
+			CycleColors: true,
+		}),
+		cancel: cancel,
+	}
+
+	prog := tea.NewProgram(
+		model,
+		tea.WithOutput(os.Stderr),
+		tea.WithContext(ctx),
+	)
+
+	return &Spinner{
+		prog: prog,
+		done: make(chan struct{}, 1),
+	}
+}
+
+// Start begins the spinner animation
+func (s *Spinner) Start() {
+	go func() {
+		defer close(s.done)
+		_, err := s.prog.Run()
+		// ensures line is cleared
+		fmt.Fprint(os.Stderr, ansi.EraseEntireLine)
+		if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, tea.ErrInterrupted) {
+			fmt.Fprintf(os.Stderr, "Error running spinner: %v\n", err)
+		}
+	}()
+}
+
+// Stop ends the spinner animation
+func (s *Spinner) Stop() {
+	s.prog.Quit()
+	<-s.done
+}

projects/ui/crush/internal/fsext/expand.go

@@ -0,0 +1,29 @@
+package fsext
+
+import (
+	"os"
+	"strings"
+
+	"mvdan.cc/sh/v3/expand"
+	"mvdan.cc/sh/v3/syntax"
+)
+
+// Expand is a wrapper around [expand.Literal]. It will escape the input
+// string, expand any shell symbols (such as '~') and resolve any environment
+// variables.
+func Expand(s string) (string, error) {
+	if s == "" {
+		return "", nil
+	}
+	p := syntax.NewParser()
+	word, err := p.Document(strings.NewReader(s))
+	if err != nil {
+		return "", err
+	}
+	cfg := &expand.Config{
+		Env:      expand.FuncEnviron(os.Getenv),
+		ReadDir2: os.ReadDir,
+		GlobStar: true,
+	}
+	return expand.Literal(cfg, word)
+}

projects/ui/crush/internal/fsext/fileutil.go

@@ -0,0 +1,247 @@
+package fsext
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/bmatcuk/doublestar/v4"
+	"github.com/charlievieth/fastwalk"
+	"github.com/charmbracelet/crush/internal/home"
+
+	ignore "github.com/sabhiram/go-gitignore"
+)
+
+type FileInfo struct {
+	Path    string
+	ModTime time.Time
+}
+
+func SkipHidden(path string) bool {
+	// Check for hidden files (starting with a dot)
+	base := filepath.Base(path)
+	if base != "." && strings.HasPrefix(base, ".") {
+		return true
+	}
+
+	commonIgnoredDirs := map[string]bool{
+		".crush":           true,
+		"node_modules":     true,
+		"vendor":           true,
+		"dist":             true,
+		"build":            true,
+		"target":           true,
+		".git":             true,
+		".idea":            true,
+		".vscode":          true,
+		"__pycache__":      true,
+		"bin":              true,
+		"obj":              true,
+		"out":              true,
+		"coverage":         true,
+		"logs":             true,
+		"generated":        true,
+		"bower_components": true,
+		"jspm_packages":    true,
+	}
+
+	parts := strings.SplitSeq(path, string(os.PathSeparator))
+	for part := range parts {
+		if commonIgnoredDirs[part] {
+			return true
+		}
+	}
+	return false
+}
+
+// FastGlobWalker provides gitignore-aware file walking with fastwalk
+type FastGlobWalker struct {
+	gitignore   *ignore.GitIgnore
+	crushignore *ignore.GitIgnore
+	rootPath    string
+}
+
+func NewFastGlobWalker(searchPath string) *FastGlobWalker {
+	walker := &FastGlobWalker{
+		rootPath: searchPath,
+	}
+
+	// Load gitignore if it exists
+	gitignorePath := filepath.Join(searchPath, ".gitignore")
+	if _, err := os.Stat(gitignorePath); err == nil {
+		if gi, err := ignore.CompileIgnoreFile(gitignorePath); err == nil {
+			walker.gitignore = gi
+		}
+	}
+
+	// Load crushignore if it exists
+	crushignorePath := filepath.Join(searchPath, ".crushignore")
+	if _, err := os.Stat(crushignorePath); err == nil {
+		if ci, err := ignore.CompileIgnoreFile(crushignorePath); err == nil {
+			walker.crushignore = ci
+		}
+	}
+
+	return walker
+}
+
+// ShouldSkip checks if a path should be skipped based on gitignore, crushignore, and hidden file rules
+func (w *FastGlobWalker) ShouldSkip(path string) bool {
+	if SkipHidden(path) {
+		return true
+	}
+
+	relPath, err := filepath.Rel(w.rootPath, path)
+	if err != nil {
+		return false
+	}
+
+	if w.gitignore != nil {
+		if w.gitignore.MatchesPath(relPath) {
+			return true
+		}
+	}
+
+	if w.crushignore != nil {
+		if w.crushignore.MatchesPath(relPath) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func GlobWithDoubleStar(pattern, searchPath string, limit int) ([]string, bool, error) {
+	walker := NewFastGlobWalker(searchPath)
+	var matches []FileInfo
+	conf := fastwalk.Config{
+		Follow: true,
+		// Use forward slashes when running a Windows binary under WSL or MSYS
+		ToSlash: fastwalk.DefaultToSlash(),
+		Sort:    fastwalk.SortFilesFirst,
+	}
+	err := fastwalk.Walk(&conf, searchPath, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil // Skip files we can't access
+		}
+
+		if d.IsDir() {
+			if walker.ShouldSkip(path) {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		if walker.ShouldSkip(path) {
+			return nil
+		}
+
+		// Check if path matches the pattern
+		relPath, err := filepath.Rel(searchPath, path)
+		if err != nil {
+			relPath = path
+		}
+
+		matched, err := doublestar.Match(pattern, relPath)
+		if err != nil || !matched {
+			return nil
+		}
+
+		info, err := d.Info()
+		if err != nil {
+			return nil
+		}
+
+		matches = append(matches, FileInfo{Path: path, ModTime: info.ModTime()})
+		if limit > 0 && len(matches) >= limit*2 {
+			return filepath.SkipAll
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, false, fmt.Errorf("fastwalk error: %w", err)
+	}
+
+	sort.Slice(matches, func(i, j int) bool {
+		return matches[i].ModTime.After(matches[j].ModTime)
+	})
+
+	truncated := false
+	if limit > 0 && len(matches) > limit {
+		matches = matches[:limit]
+		truncated = true
+	}
+
+	results := make([]string, len(matches))
+	for i, m := range matches {
+		results[i] = m.Path
+	}
+	return results, truncated, nil
+}
+
+func PrettyPath(path string) string {
+	return home.Short(path)
+}
+
+func DirTrim(pwd string, lim int) string {
+	var (
+		out string
+		sep = string(filepath.Separator)
+	)
+	dirs := strings.Split(pwd, sep)
+	if lim > len(dirs)-1 || lim <= 0 {
+		return pwd
+	}
+	for i := len(dirs) - 1; i > 0; i-- {
+		out = sep + out
+		if i == len(dirs)-1 {
+			out = dirs[i]
+		} else if i >= len(dirs)-lim {
+			out = string(dirs[i][0]) + out
+		} else {
+			out = "..." + out
+			break
+		}
+	}
+	out = filepath.Join("~", out)
+	return out
+}
+
+// PathOrPrefix returns the prefix if the path starts with it, or falls back to
+// the path otherwise.
+func PathOrPrefix(path, prefix string) string {
+	if HasPrefix(path, prefix) {
+		return prefix
+	}
+	return path
+}
+
+// HasPrefix checks if the given path starts with the specified prefix.
+// Uses filepath.Rel to determine if path is within prefix.
+func HasPrefix(path, prefix string) bool {
+	rel, err := filepath.Rel(prefix, path)
+	if err != nil {
+		return false
+	}
+	// If path is within prefix, Rel will not return a path starting with ".."
+	return !strings.HasPrefix(rel, "..")
+}
+
+// ToUnixLineEndings converts Windows line endings (CRLF) to Unix line endings (LF).
+func ToUnixLineEndings(content string) (string, bool) {
+	if strings.Contains(content, "\r\n") {
+		return strings.ReplaceAll(content, "\r\n", "\n"), true
+	}
+	return content, false
+}
+
+// ToWindowsLineEndings converts Unix line endings (LF) to Windows line endings (CRLF).
+func ToWindowsLineEndings(content string) (string, bool) {
+	if !strings.Contains(content, "\r\n") {
+		return strings.ReplaceAll(content, "\n", "\r\n"), true
+	}
+	return content, false
+}

projects/ui/crush/internal/fsext/ignore_test.go

@@ -0,0 +1,32 @@
+package fsext
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCrushIgnore(t *testing.T) {
+	// Create a temporary directory for testing
+	tempDir := t.TempDir()
+
+	// Change to temp directory
+	oldWd, _ := os.Getwd()
+	err := os.Chdir(tempDir)
+	require.NoError(t, err)
+	defer os.Chdir(oldWd)
+
+	// Create test files
+	require.NoError(t, os.WriteFile("test1.txt", []byte("test"), 0o644))
+	require.NoError(t, os.WriteFile("test2.log", []byte("test"), 0o644))
+	require.NoError(t, os.WriteFile("test3.tmp", []byte("test"), 0o644))
+
+	// Create a .crushignore file that ignores .log files
+	require.NoError(t, os.WriteFile(".crushignore", []byte("*.log\n"), 0o644))
+
+	dl := NewDirectoryLister(tempDir)
+	require.True(t, dl.shouldIgnore("test2.log", nil), ".log files should be ignored")
+	require.False(t, dl.shouldIgnore("test1.txt", nil), ".txt files should not be ignored")
+	require.True(t, dl.shouldIgnore("test3.tmp", nil), ".tmp files should be ignored by common patterns")
+}

projects/ui/crush/internal/fsext/ls.go

@@ -0,0 +1,234 @@
+package fsext
+
+import (
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/charlievieth/fastwalk"
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/home"
+	ignore "github.com/sabhiram/go-gitignore"
+)
+
+// commonIgnorePatterns contains commonly ignored files and directories
+var commonIgnorePatterns = sync.OnceValue(func() ignore.IgnoreParser {
+	return ignore.CompileIgnoreLines(
+		// Version control
+		".git",
+		".svn",
+		".hg",
+		".bzr",
+
+		// IDE and editor files
+		".vscode",
+		".idea",
+		"*.swp",
+		"*.swo",
+		"*~",
+		".DS_Store",
+		"Thumbs.db",
+
+		// Build artifacts and dependencies
+		"node_modules",
+		"target",
+		"build",
+		"dist",
+		"out",
+		"bin",
+		"obj",
+		"*.o",
+		"*.so",
+		"*.dylib",
+		"*.dll",
+		"*.exe",
+
+		// Logs and temporary files
+		"*.log",
+		"*.tmp",
+		"*.temp",
+		".cache",
+		".tmp",
+
+		// Language-specific
+		"__pycache__",
+		"*.pyc",
+		"*.pyo",
+		".pytest_cache",
+		"vendor",
+		"Cargo.lock",
+		"package-lock.json",
+		"yarn.lock",
+		"pnpm-lock.yaml",
+
+		// OS generated files
+		".Trash",
+		".Spotlight-V100",
+		".fseventsd",
+
+		// Crush
+		".crush",
+	)
+})
+
+var homeIgnore = sync.OnceValue(func() ignore.IgnoreParser {
+	home := home.Dir()
+	var lines []string
+	for _, name := range []string{
+		filepath.Join(home, ".gitignore"),
+		filepath.Join(home, ".config", "git", "ignore"),
+		filepath.Join(home, ".config", "crush", "ignore"),
+	} {
+		if bts, err := os.ReadFile(name); err == nil {
+			lines = append(lines, strings.Split(string(bts), "\n")...)
+		}
+	}
+	return ignore.CompileIgnoreLines(lines...)
+})
+
+type directoryLister struct {
+	ignores  *csync.Map[string, ignore.IgnoreParser]
+	rootPath string
+}
+
+func NewDirectoryLister(rootPath string) *directoryLister {
+	dl := &directoryLister{
+		rootPath: rootPath,
+		ignores:  csync.NewMap[string, ignore.IgnoreParser](),
+	}
+	dl.getIgnore(rootPath)
+	return dl
+}
+
+// git checks, in order:
+// - ./.gitignore, ../.gitignore, etc, until repo root
+// ~/.config/git/ignore
+// ~/.gitignore
+//
+// This will do the following:
+// - the given ignorePatterns
+// - [commonIgnorePatterns]
+// - ./.gitignore, ../.gitignore, etc, until dl.rootPath
+// - ./.crushignore, ../.crushignore, etc, until dl.rootPath
+// ~/.config/git/ignore
+// ~/.gitignore
+// ~/.config/crush/ignore
+func (dl *directoryLister) shouldIgnore(path string, ignorePatterns []string) bool {
+	if len(ignorePatterns) > 0 {
+		base := filepath.Base(path)
+		for _, pattern := range ignorePatterns {
+			if matched, err := filepath.Match(pattern, base); err == nil && matched {
+				return true
+			}
+		}
+	}
+
+	// Don't apply gitignore rules to the root directory itself
+	// In gitignore semantics, patterns don't apply to the repo root
+	if path == dl.rootPath {
+		return false
+	}
+
+	relPath, err := filepath.Rel(dl.rootPath, path)
+	if err != nil {
+		relPath = path
+	}
+
+	if commonIgnorePatterns().MatchesPath(relPath) {
+		slog.Debug("ignoring common pattern", "path", relPath)
+		return true
+	}
+
+	if dl.getIgnore(filepath.Dir(path)).MatchesPath(relPath) {
+		slog.Debug("ignoring dir pattern", "path", relPath, "dir", filepath.Dir(path))
+		return true
+	}
+
+	if dl.checkParentIgnores(relPath) {
+		return true
+	}
+
+	if homeIgnore().MatchesPath(relPath) {
+		slog.Debug("ignoring home dir pattern", "path", relPath)
+		return true
+	}
+
+	return false
+}
+
+func (dl *directoryLister) checkParentIgnores(path string) bool {
+	parent := filepath.Dir(filepath.Dir(path))
+	for parent != dl.rootPath && parent != "." && path != "." {
+		if dl.getIgnore(parent).MatchesPath(path) {
+			slog.Debug("ingoring parent dir pattern", "path", path, "dir", parent)
+			return true
+		}
+		parent = filepath.Dir(parent)
+	}
+	return false
+}
+
+func (dl *directoryLister) getIgnore(path string) ignore.IgnoreParser {
+	return dl.ignores.GetOrSet(path, func() ignore.IgnoreParser {
+		var lines []string
+		for _, ign := range []string{".crushignore", ".gitignore"} {
+			name := filepath.Join(path, ign)
+			if content, err := os.ReadFile(name); err == nil {
+				lines = append(lines, strings.Split(string(content), "\n")...)
+			}
+		}
+		if len(lines) == 0 {
+			// Return a no-op parser to avoid nil checks
+			return ignore.CompileIgnoreLines()
+		}
+		return ignore.CompileIgnoreLines(lines...)
+	})
+}
+
+// ListDirectory lists files and directories in the specified path,
+func ListDirectory(initialPath string, ignorePatterns []string, limit int) ([]string, bool, error) {
+	var results []string
+	truncated := false
+	dl := NewDirectoryLister(initialPath)
+
+	conf := fastwalk.Config{
+		Follow: true,
+		// Use forward slashes when running a Windows binary under WSL or MSYS
+		ToSlash: fastwalk.DefaultToSlash(),
+		Sort:    fastwalk.SortDirsFirst,
+	}
+
+	err := fastwalk.Walk(&conf, initialPath, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil // Skip files we don't have permission to access
+		}
+
+		if dl.shouldIgnore(path, ignorePatterns) {
+			if d.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		if path != initialPath {
+			if d.IsDir() {
+				path = path + string(filepath.Separator)
+			}
+			results = append(results, path)
+		}
+
+		if limit > 0 && len(results) >= limit {
+			truncated = true
+			return filepath.SkipAll
+		}
+
+		return nil
+	})
+	if err != nil && len(results) == 0 {
+		return nil, truncated, err
+	}
+
+	return results, truncated, nil
+}

projects/ui/crush/internal/fsext/ls_test.go

@@ -0,0 +1,66 @@
+package fsext
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func chdir(t *testing.T, dir string) {
+	original, err := os.Getwd()
+	require.NoError(t, err)
+
+	err = os.Chdir(dir)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		err := os.Chdir(original)
+		require.NoError(t, err)
+	})
+}
+
+func TestListDirectory(t *testing.T) {
+	tempDir := t.TempDir()
+	chdir(t, tempDir)
+
+	testFiles := map[string]string{
+		"regular.txt":     "content",
+		".hidden":         "hidden content",
+		".gitignore":      ".*\n*.log\n",
+		"subdir/file.go":  "package main",
+		"subdir/.another": "more hidden",
+		"build.log":       "build output",
+	}
+
+	for filePath, content := range testFiles {
+		dir := filepath.Dir(filePath)
+		if dir != "." {
+			require.NoError(t, os.MkdirAll(dir, 0o755))
+		}
+
+		err := os.WriteFile(filePath, []byte(content), 0o644)
+		require.NoError(t, err)
+	}
+
+	files, truncated, err := ListDirectory(".", nil, 0)
+	require.NoError(t, err)
+	assert.False(t, truncated)
+	assert.Equal(t, len(files), 4)
+
+	fileSet := make(map[string]bool)
+	for _, file := range files {
+		fileSet[filepath.ToSlash(file)] = true
+	}
+
+	assert.True(t, fileSet["./regular.txt"])
+	assert.True(t, fileSet["./subdir/"])
+	assert.True(t, fileSet["./subdir/file.go"])
+	assert.True(t, fileSet["./regular.txt"])
+
+	assert.False(t, fileSet["./.hidden"])
+	assert.False(t, fileSet["./.gitignore"])
+	assert.False(t, fileSet["./build.log"])
+}

projects/ui/crush/internal/fsext/owner_others.go

@@ -0,0 +1,24 @@
+//go:build !windows
+
+package fsext
+
+import (
+	"os"
+	"syscall"
+)
+
+// Owner retrieves the user ID of the owner of the file or directory at the
+// specified path.
+func Owner(path string) (int, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return 0, err
+	}
+	var uid int
+	if stat, ok := info.Sys().(*syscall.Stat_t); ok {
+		uid = int(stat.Uid)
+	} else {
+		uid = os.Getuid()
+	}
+	return uid, nil
+}

projects/ui/crush/internal/fsext/owner_windows.go

@@ -0,0 +1,9 @@
+//go:build windows
+
+package fsext
+
+// Owner retrieves the user ID of the owner of the file or directory at the
+// specified path.
+func Owner(path string) (int, error) {
+	return -1, nil
+}

projects/ui/crush/internal/fsext/parent.go

@@ -0,0 +1,60 @@
+package fsext
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+
+	"github.com/charmbracelet/crush/internal/home"
+)
+
+// SearchParent searches for a target file or directory starting from dir
+// and walking up the directory tree until found or root or home is reached.
+// It also checks the ownership of directories to ensure that the search does
+// not cross ownership boundaries.
+// Returns the full path to the target if found, empty string and false otherwise.
+// The search includes the starting directory itself.
+func SearchParent(dir, target string) (string, bool) {
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return "", false
+	}
+
+	path := filepath.Join(absDir, target)
+	if _, err := os.Stat(path); err == nil {
+		return path, true
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return "", false
+	}
+
+	previousParent := absDir
+	previousOwner, err := Owner(previousParent)
+	if err != nil {
+		return "", false
+	}
+
+	for {
+		parent := filepath.Dir(previousParent)
+		if parent == previousParent || parent == home.Dir() {
+			return "", false
+		}
+
+		parentOwner, err := Owner(parent)
+		if err != nil {
+			return "", false
+		}
+		if parentOwner != previousOwner {
+			return "", false
+		}
+
+		path := filepath.Join(parent, target)
+		if _, err := os.Stat(path); err == nil {
+			return path, true
+		} else if !errors.Is(err, os.ErrNotExist) {
+			return "", false
+		}
+
+		previousParent = parent
+		previousOwner = parentOwner
+	}
+}

projects/ui/crush/internal/history/file.go

@@ -0,0 +1,210 @@
+package history
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/pubsub"
+	"github.com/google/uuid"
+)
+
+const (
+	InitialVersion = 0
+)
+
+type File struct {
+	ID        string
+	SessionID string
+	Path      string
+	Content   string
+	Version   int64
+	CreatedAt int64
+	UpdatedAt int64
+}
+
+type Service interface {
+	pubsub.Suscriber[File]
+	Create(ctx context.Context, sessionID, path, content string) (File, error)
+	CreateVersion(ctx context.Context, sessionID, path, content string) (File, error)
+	Get(ctx context.Context, id string) (File, error)
+	GetByPathAndSession(ctx context.Context, path, sessionID string) (File, error)
+	ListBySession(ctx context.Context, sessionID string) ([]File, error)
+	ListLatestSessionFiles(ctx context.Context, sessionID string) ([]File, error)
+	Delete(ctx context.Context, id string) error
+	DeleteSessionFiles(ctx context.Context, sessionID string) error
+}
+
+type service struct {
+	*pubsub.Broker[File]
+	db *sql.DB
+	q  *db.Queries
+}
+
+func NewService(q *db.Queries, db *sql.DB) Service {
+	return &service{
+		Broker: pubsub.NewBroker[File](),
+		q:      q,
+		db:     db,
+	}
+}
+
+func (s *service) Create(ctx context.Context, sessionID, path, content string) (File, error) {
+	return s.createWithVersion(ctx, sessionID, path, content, InitialVersion)
+}
+
+func (s *service) CreateVersion(ctx context.Context, sessionID, path, content string) (File, error) {
+	// Get the latest version for this path
+	files, err := s.q.ListFilesByPath(ctx, path)
+	if err != nil {
+		return File{}, err
+	}
+
+	if len(files) == 0 {
+		// No previous versions, create initial
+		return s.Create(ctx, sessionID, path, content)
+	}
+
+	// Get the latest version
+	latestFile := files[0] // Files are ordered by version DESC, created_at DESC
+	nextVersion := latestFile.Version + 1
+
+	return s.createWithVersion(ctx, sessionID, path, content, nextVersion)
+}
+
+func (s *service) createWithVersion(ctx context.Context, sessionID, path, content string, version int64) (File, error) {
+	// Maximum number of retries for transaction conflicts
+	const maxRetries = 3
+	var file File
+	var err error
+
+	// Retry loop for transaction conflicts
+	for attempt := range maxRetries {
+		// Start a transaction
+		tx, txErr := s.db.BeginTx(ctx, nil)
+		if txErr != nil {
+			return File{}, fmt.Errorf("failed to begin transaction: %w", txErr)
+		}
+
+		// Create a new queries instance with the transaction
+		qtx := s.q.WithTx(tx)
+
+		// Try to create the file within the transaction
+		dbFile, txErr := qtx.CreateFile(ctx, db.CreateFileParams{
+			ID:        uuid.New().String(),
+			SessionID: sessionID,
+			Path:      path,
+			Content:   content,
+			Version:   version,
+		})
+		if txErr != nil {
+			// Rollback the transaction
+			tx.Rollback()
+
+			// Check if this is a uniqueness constraint violation
+			if strings.Contains(txErr.Error(), "UNIQUE constraint failed") {
+				if attempt < maxRetries-1 {
+					// If we have retries left, increment version and try again
+					version++
+					continue
+				}
+			}
+			return File{}, txErr
+		}
+
+		// Commit the transaction
+		if txErr = tx.Commit(); txErr != nil {
+			return File{}, fmt.Errorf("failed to commit transaction: %w", txErr)
+		}
+
+		file = s.fromDBItem(dbFile)
+		s.Publish(pubsub.CreatedEvent, file)
+		return file, nil
+	}
+
+	return file, err
+}
+
+func (s *service) Get(ctx context.Context, id string) (File, error) {
+	dbFile, err := s.q.GetFile(ctx, id)
+	if err != nil {
+		return File{}, err
+	}
+	return s.fromDBItem(dbFile), nil
+}
+
+func (s *service) GetByPathAndSession(ctx context.Context, path, sessionID string) (File, error) {
+	dbFile, err := s.q.GetFileByPathAndSession(ctx, db.GetFileByPathAndSessionParams{
+		Path:      path,
+		SessionID: sessionID,
+	})
+	if err != nil {
+		return File{}, err
+	}
+	return s.fromDBItem(dbFile), nil
+}
+
+func (s *service) ListBySession(ctx context.Context, sessionID string) ([]File, error) {
+	dbFiles, err := s.q.ListFilesBySession(ctx, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	files := make([]File, len(dbFiles))
+	for i, dbFile := range dbFiles {
+		files[i] = s.fromDBItem(dbFile)
+	}
+	return files, nil
+}
+
+func (s *service) ListLatestSessionFiles(ctx context.Context, sessionID string) ([]File, error) {
+	dbFiles, err := s.q.ListLatestSessionFiles(ctx, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	files := make([]File, len(dbFiles))
+	for i, dbFile := range dbFiles {
+		files[i] = s.fromDBItem(dbFile)
+	}
+	return files, nil
+}
+
+func (s *service) Delete(ctx context.Context, id string) error {
+	file, err := s.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+	err = s.q.DeleteFile(ctx, id)
+	if err != nil {
+		return err
+	}
+	s.Publish(pubsub.DeletedEvent, file)
+	return nil
+}
+
+func (s *service) DeleteSessionFiles(ctx context.Context, sessionID string) error {
+	files, err := s.ListBySession(ctx, sessionID)
+	if err != nil {
+		return err
+	}
+	for _, file := range files {
+		err = s.Delete(ctx, file.ID)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *service) fromDBItem(item db.File) File {
+	return File{
+		ID:        item.ID,
+		SessionID: item.SessionID,
+		Path:      item.Path,
+		Content:   item.Content,
+		Version:   item.Version,
+		CreatedAt: item.CreatedAt,
+		UpdatedAt: item.UpdatedAt,
+	}
+}