108 lines
3.1 KiB
Go
108 lines
3.1 KiB
Go
package models
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
// WorkspaceState represents the current state of the workspace
|
|
type WorkspaceState struct {
|
|
// CurrentCommitSHA is the SHA of the current ephemeral commit
|
|
CurrentCommitSHA string `json:"current_commit_sha"`
|
|
|
|
// WorkstreamName is the name of the active workstream
|
|
WorkstreamName string `json:"workstream_name"`
|
|
|
|
// LastSnapshot is when the last automatic snapshot was created
|
|
LastSnapshot time.Time `json:"last_snapshot"`
|
|
|
|
// IsDirty indicates if there are uncommitted changes
|
|
IsDirty bool `json:"is_dirty"`
|
|
|
|
// TreeHash is the hash of the current working tree
|
|
TreeHash string `json:"tree_hash,omitempty"`
|
|
|
|
// IndexHash is the hash of the staging area
|
|
IndexHash string `json:"index_hash,omitempty"`
|
|
|
|
// Metadata contains additional workspace-specific data
|
|
Metadata map[string]string `json:"metadata,omitempty"`
|
|
}
|
|
|
|
// NewWorkspaceState creates a new workspace state
|
|
func NewWorkspaceState(commitSHA, workstreamName string) *WorkspaceState {
|
|
return &WorkspaceState{
|
|
CurrentCommitSHA: commitSHA,
|
|
WorkstreamName: workstreamName,
|
|
LastSnapshot: time.Now(),
|
|
IsDirty: false,
|
|
Metadata: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
// UpdateSnapshot updates the workspace state with a new snapshot
|
|
func (ws *WorkspaceState) UpdateSnapshot(commitSHA, treeHash, indexHash string, isDirty bool) {
|
|
ws.CurrentCommitSHA = commitSHA
|
|
ws.TreeHash = treeHash
|
|
ws.IndexHash = indexHash
|
|
ws.IsDirty = isDirty
|
|
ws.LastSnapshot = time.Now()
|
|
}
|
|
|
|
// SetWorkstream changes the active workstream
|
|
func (ws *WorkspaceState) SetWorkstream(workstreamName string) {
|
|
ws.WorkstreamName = workstreamName
|
|
}
|
|
|
|
// MarkDirty marks the workspace as having uncommitted changes
|
|
func (ws *WorkspaceState) MarkDirty() {
|
|
ws.IsDirty = true
|
|
}
|
|
|
|
// MarkClean marks the workspace as clean (no uncommitted changes)
|
|
func (ws *WorkspaceState) MarkClean() {
|
|
ws.IsDirty = false
|
|
}
|
|
|
|
// Serialize converts the workspace state to JSON
|
|
func (ws *WorkspaceState) Serialize() ([]byte, error) {
|
|
data, err := json.MarshalIndent(ws, "", " ")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal workspace state: %w", err)
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
// DeserializeWorkspaceState converts JSON data to a workspace state
|
|
func DeserializeWorkspaceState(data []byte) (*WorkspaceState, error) {
|
|
ws := &WorkspaceState{}
|
|
if err := json.Unmarshal(data, ws); err != nil {
|
|
return nil, fmt.Errorf("failed to unmarshal workspace state: %w", err)
|
|
}
|
|
return ws, nil
|
|
}
|
|
|
|
// GetTimeSinceLastSnapshot returns the duration since the last snapshot
|
|
func (ws *WorkspaceState) GetTimeSinceLastSnapshot() time.Duration {
|
|
return time.Since(ws.LastSnapshot)
|
|
}
|
|
|
|
// Clone creates a deep copy of the workspace state
|
|
func (ws *WorkspaceState) Clone() *WorkspaceState {
|
|
metadata := make(map[string]string, len(ws.Metadata))
|
|
for k, v := range ws.Metadata {
|
|
metadata[k] = v
|
|
}
|
|
|
|
return &WorkspaceState{
|
|
CurrentCommitSHA: ws.CurrentCommitSHA,
|
|
WorkstreamName: ws.WorkstreamName,
|
|
LastSnapshot: ws.LastSnapshot,
|
|
IsDirty: ws.IsDirty,
|
|
TreeHash: ws.TreeHash,
|
|
IndexHash: ws.IndexHash,
|
|
Metadata: metadata,
|
|
}
|
|
}
|