temp for tree extraction

internal/models/workspace.go

@@ -0,0 +1,107 @@
+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,
+	}
+}