diff --git a/.archive/Makefile.backup b/.archive/Makefile.backup
deleted file mode 100644
index d286d44..0000000
--- a/.archive/Makefile.backup
+++ /dev/null
@@ -1,82 +0,0 @@
-#-----------------------------------------------------------------------------#
-# Makefile for Omnivex
-#-----------------------------------------------------------------------------#
-
-APP_NAME := omnivex
-BUILD_DIR := build
-ZARF_BINARY := zarf
-
-# Define colors for output
-GREEN := \033[0;32m
-YELLOW := \033[1;33m
-RED := \033[0;31m
-NC := \033[0m # No Color
-
-#-----------------------------------------------------------------------------#
-# Get the latest Zarf version from GitHub
-#-----------------------------------------------------------------------------#
-latest_zarf_version = $(shell curl -s https://api.github.com/repos/defenseunicorns/zarf/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
-
-#-----------------------------------------------------------------------------#
-# Phony Targets
-#-----------------------------------------------------------------------------#
-.PHONY: all install-deps build run clean help
-
-#-----------------------------------------------------------------------------#
-# Default Target
-#-----------------------------------------------------------------------------#
-all: build
-
-#-----------------------------------------------------------------------------#
-# Install dependencies and download the latest Zarf binary if necessary
-#-----------------------------------------------------------------------------#
-install-deps:
-	@echo -e "$(YELLOW)Checking and installing dependencies...$(NC)"
-	@./scripts/install_dependencies.sh
-
-	@echo -e "$(GREEN)Dependencies installed successfully.$(NC)"
-
-#-----------------------------------------------------------------------------#
-# Build the application
-#-----------------------------------------------------------------------------#
-build: install-deps
-	@echo -e "$(YELLOW)Building $(APP_NAME)...$(NC)"
-	@mkdir -p $(BUILD_DIR)
-	@go build -o $(BUILD_DIR)/$(APP_NAME) main.go packager.go unpackager.go api.go
-	@echo -e "$(GREEN)Build complete. Executable available at $(BUILD_DIR)/$(APP_NAME)$(NC)"
-
-#-----------------------------------------------------------------------------#
-# Run the application
-#-----------------------------------------------------------------------------#
-run: build
-	@echo -e "$(YELLOW)Running $(APP_NAME)...$(NC)"
-	@ZARF_BINARY=$(BUILD_DIR)/$(ZARF_BINARY) $(BUILD_DIR)/$(APP_NAME)
-
-#-----------------------------------------------------------------------------#
-# Clean up build artifacts
-#-----------------------------------------------------------------------------#
-clean:
-	@echo -e "$(YELLOW)Cleaning up...$(NC)"
-	@rm -rf $(BUILD_DIR)
-	@echo -e "$(GREEN)Cleanup complete.$(NC)"
-
-#-----------------------------------------------------------------------------#
-# Display available make commands
-#-----------------------------------------------------------------------------#
-help:
-	@echo "Available commands:"
-	@echo "  make install-deps - Installs necessary dependencies and downloads the latest Zarf"
-	@echo "  make build        - Builds the application"
-	@echo "  make run          - Runs the application"
-	@echo "  make clean        - Cleans up build artifacts"
-	@echo "  make help         - Shows this help message"
-
-#-----------------------------------------------------------------------------#
-# Download the latest Zarf binary if not present
-#-----------------------------------------------------------------------------#
-download-zarf:
-	@echo -e "$(YELLOW)Downloading Zarf version $(latest_zarf_version)...$(NC)"
-	@mkdir -p $(BUILD_DIR)
-	@curl -Lo $(BUILD_DIR)/$(ZARF_BINARY) https://github.com/defenseunicorns/zarf/releases/download/$(latest_zarf_version)/zarf_$(latest_zarf_version)_linux_amd64
-	@chmod +x $(BUILD_DIR)/$(ZARF_BINARY)
-	@echo -e "$(GREEN)Zarf downloaded successfully.$(NC)"
diff --git a/.archive/package.gobackup b/.archive/package.gobackup
deleted file mode 100644
index 92b136b..0000000
--- a/.archive/package.gobackup
+++ /dev/null
@@ -1,483 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/charmbracelet/bubbles/list"
-	"github.com/charmbracelet/bubbles/spinner"
-	"github.com/charmbracelet/bubbles/textinput"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/joho/godotenv"
-)
-
-// Styles
-var (
-	titleStyle    = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("63"))
-	itemStyle     = lipgloss.NewStyle().Foreground(lipgloss.Color("69"))
-	selectedStyle = lipgloss.NewStyle().Background(lipgloss.Color("31")).Bold(true)
-	errorStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("196"))
-	helpStyle     = lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
-	successStyle  = lipgloss.NewStyle().Foreground(lipgloss.Color("42"))
-)
-
-// Screen represents different UI states
-type Screen int
-
-const (
-	ScreenHome Screen = iota
-	ScreenPackages
-	ScreenDetails
-	ScreenAddPackage
-	ScreenModifyPackage
-)
-
-type CompressionLevel int
-
-const (
-	CompressionFast CompressionLevel = iota
-	CompressionBalanced
-	CompressionHigh
-)
-
-var compressionOptions = []string{
-	"Fast",
-	"Balanced",
-	"High",
-}
-
-// Artifact represents a package with its metadata
-type Artifact struct {
-	Name      string
-	Version   string
-	Desc      string
-	Type      string
-	Source    string
-	CreatedAt time.Time
-	UpdatedAt time.Time
-}
-
-// PackageManager manages package artifacts
-type PackageManager struct {
-	basePath         string
-	compressionLevel CompressionLevel
-}
-
-// NewPackageManager creates a new PackageManager
-func NewPackageManager(path string, level CompressionLevel) (*PackageManager, error) {
-	return &PackageManager{
-		basePath:         path,
-		compressionLevel: level,
-	}, nil
-}
-
-func (pm *PackageManager) ListArtifacts() []Artifact {
-	// Placeholder implementation
-	return []Artifact{
-		{Name: "example", Version: "1.0.0", Desc: "Example package", Type: "docker", Source: "https://example.com", CreatedAt: time.Now(), UpdatedAt: time.Now()},
-	}
-}
-
-func (pm *PackageManager) AddArtifact(artifact Artifact) error {
-	// Placeholder implementation
-	fmt.Printf("Adding artifact: %+v\n", artifact)
-	return nil
-}
-
-func (pm *PackageManager) ModifyArtifact(name string, updates Artifact) error {
-	// Placeholder implementation
-	fmt.Printf("Modifying artifact: %s with updates: %+v\n", name, updates)
-	return nil
-}
-
-func (pm *PackageManager) RemoveArtifact(name string) error {
-	// Placeholder implementation
-	fmt.Printf("Removing artifact: %s\n", name)
-	return nil
-}
-
-func (pm *PackageManager) PackageArtifact(ctx context.Context, name string) error {
-	// Placeholder implementation
-	fmt.Printf("Packaging artifact: %s\n", name)
-	return nil
-}
-
-func (pm *PackageManager) UnpackageArtifact(ctx context.Context, name, dest string) error {
-	// Placeholder implementation
-	fmt.Printf("Unpackaging artifact: %s to destination: %s\n", name, dest)
-	return nil
-}
-
-func (a Artifact) Title() string { return a.Name }
-func (a Artifact) Description() string {
-	return fmt.Sprintf("%s | %s | %s", a.Type, a.Version, a.Desc)
-}
-func (a Artifact) FilterValue() string { return a.Name }
-
-// Model represents the application state
-type Model struct {
-	screen           Screen
-	list             list.Model
-	spinner          spinner.Model
-	selected         *Artifact
-	packageManager   *PackageManager
-	compressionLevel CompressionLevel
-	errorMsg         string
-	successMsg       string
-	inputs           []textinput.Model
-	focusIndex       int
-	working          bool
-}
-
-func initialModel() Model {
-	// Initialize package manager
-	pm, err := NewPackageManager("/tmp/packages", CompressionBalanced)
-	if err != nil {
-		fmt.Printf("Failed to initialize package manager: %v\n", err)
-		os.Exit(1)
-	}
-
-	// Initialize text inputs for add/modify forms
-	inputs := make([]textinput.Model, 5)
-	for i := range inputs {
-		t := textinput.New()
-		switch i {
-		case 0:
-			t.Placeholder = "Package Name"
-			t.Focus()
-		case 1:
-			t.Placeholder = "Version"
-		case 2:
-			t.Placeholder = "Description"
-		case 3:
-			t.Placeholder = "Type (docker/helm/git)"
-		case 4:
-			t.Placeholder = "Source URL"
-		}
-		inputs[i] = t
-	}
-
-	// Create empty list
-	list := list.New([]list.Item{}, list.NewDefaultDelegate(), 0, 0)
-	list.Title = "Available Packages"
-
-	return Model{
-		screen:           ScreenHome,
-		list:             list,
-		spinner:          spinner.New(),
-		packageManager:   pm,
-		compressionLevel: CompressionBalanced,
-		inputs:           inputs,
-		working:          false,
-	}
-}
-
-func (m Model) Init() tea.Cmd {
-	return tea.Batch(m.spinner.Tick, m.refreshPackages)
-}
-
-func (m Model) refreshPackages() tea.Msg {
-	artifacts := m.packageManager.ListArtifacts()
-	items := make([]list.Item, len(artifacts))
-	for i, a := range artifacts {
-		items[i] = a
-	}
-	return packageListMsg(items)
-}
-
-type packageListMsg []list.Item
-type errorMsg string
-type successMsg string
-type workStartMsg struct{}
-type workEndMsg struct{}
-
-func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmds []tea.Cmd
-
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		switch msg.String() {
-		case "q", "ctrl+c":
-			return m, tea.Quit
-		case "a":
-			if m.screen == ScreenPackages {
-				m.screen = ScreenAddPackage
-				m.resetInputs()
-				m.focusIndex = 0
-				m.inputs[0].Focus()
-			}
-		case "m":
-			if m.screen == ScreenDetails {
-				m.screen = ScreenModifyPackage
-				m.populateInputsFromSelected()
-				m.focusIndex = 0
-				m.inputs[0].Focus()
-			}
-		case "d":
-			if m.screen == ScreenDetails && m.selected != nil {
-				return m, m.deletePackage(m.selected.Name)
-			}
-		case "p":
-			if m.screen == ScreenDetails && m.selected != nil {
-				return m, m.packageArtifact(m.selected.Name)
-			}
-		case "u":
-			if m.screen == ScreenDetails && m.selected != nil {
-				return m, m.unpackageArtifact(m.selected.Name)
-			}
-		case "tab", "shift+tab":
-			if m.screen == ScreenAddPackage || m.screen == ScreenModifyPackage {
-				if msg.String() == "tab" {
-					m.focusIndex = (m.focusIndex + 1) % len(m.inputs)
-				} else {
-					m.focusIndex = (m.focusIndex - 1 + len(m.inputs)) % len(m.inputs)
-				}
-				cmds = append(cmds, m.updateInputFocus())
-			}
-		case "enter":
-			switch m.screen {
-			case ScreenHome:
-				m.screen = ScreenPackages
-			case ScreenPackages:
-				if i, ok := m.list.SelectedItem().(Artifact); ok {
-					m.selected = &i
-					m.screen = ScreenDetails
-				}
-			case ScreenAddPackage:
-				return m, m.submitNewPackage()
-			case ScreenModifyPackage:
-				return m, m.submitModifiedPackage()
-			}
-		case "esc":
-			switch m.screen {
-			case ScreenDetails:
-				m.screen = ScreenPackages
-			case ScreenPackages:
-				m.screen = ScreenHome
-			case ScreenAddPackage, ScreenModifyPackage:
-				m.screen = ScreenPackages
-			}
-			m.errorMsg = ""
-			m.successMsg = ""
-		case "c":
-			m.compressionLevel = (m.compressionLevel + 1) % 3
-			m.packageManager.compressionLevel = m.compressionLevel
-		}
-
-	case packageListMsg:
-		m.list.SetItems(msg)
-
-	case workStartMsg:
-		m.working = true
-
-	case workEndMsg:
-		m.working = false
-
-	case errorMsg:
-		m.errorMsg = string(msg)
-		m.successMsg = ""
-		m.working = false
-
-	case successMsg:
-		m.successMsg = string(msg)
-		m.errorMsg = ""
-		m.working = false
-		return m, m.refreshPackages
-
-	case tea.WindowSizeMsg:
-		h, v := lipgloss.NewStyle().Margin(1, 2).GetFrameSize()
-		m.list.SetSize(msg.Width-h, msg.Height-v)
-	}
-
-	if m.screen == ScreenAddPackage || m.screen == ScreenModifyPackage {
-		var cmd tea.Cmd
-		for i := range m.inputs {
-			m.inputs[i], cmd = m.inputs[i].Update(msg)
-			cmds = append(cmds, cmd)
-		}
-	}
-
-	var cmd tea.Cmd
-	m.list, cmd = m.list.Update(msg)
-	cmds = append(cmds, cmd)
-
-	return m, tea.Batch(cmds...)
-}
-
-func (m Model) View() string {
-	if m.working {
-		return fmt.Sprintf("%s\n%s",
-			titleStyle.Render("Working..."),
-			m.spinner.View())
-	}
-
-	var content string
-	switch m.screen {
-	case ScreenHome:
-		content = fmt.Sprintf("%s\n\n%s\n\n%s",
-			titleStyle.Render("Package Manager"),
-			helpStyle.Render("Press Enter to view packages"),
-			fmt.Sprintf("Compression: %s (Press 'c' to change)", compressionOptions[m.compressionLevel]))
-
-	case ScreenPackages:
-		content = fmt.Sprintf("%s\n\n%s\n\n%s",
-			titleStyle.Render("Available Packages"),
-			m.list.View(),
-			helpStyle.Render("Press 'a' to add, Enter to view details"))
-
-	case ScreenDetails:
-		if m.selected != nil {
-			content = fmt.Sprintf("%s\n\n%s\n\n%s",
-				titleStyle.Render("Package Details"),
-				selectedStyle.Render(fmt.Sprintf(
-					"Name: %s\nType: %s\nVersion: %s\nDescription: %s\nSource: %s\nCreated: %s\nUpdated: %s",
-					m.selected.Name, m.selected.Type, m.selected.Version,
-					m.selected.Description, m.selected.Source,
-					m.selected.CreatedAt.Format(time.RFC822),
-					m.selected.UpdatedAt.Format(time.RFC822))),
-				helpStyle.Render("'m' to modify, 'd' to delete, 'p' to package, 'u' to unpackage"))
-		}
-
-	case ScreenAddPackage:
-		content = m.renderForm("Add New Package")
-
-	case ScreenModifyPackage:
-		content = m.renderForm("Modify Package")
-	}
-
-	if m.errorMsg != "" {
-		content = fmt.Sprintf("%s\n\n%s", content, errorStyle.Render("Error: "+m.errorMsg))
-	}
-	if m.successMsg != "" {
-		content = fmt.Sprintf("%s\n\n%s", content, successStyle.Render(m.successMsg))
-	}
-
-	return content
-}
-
-func (m *Model) renderForm(title string) string {
-	var b strings.Builder
-	b.WriteString(titleStyle.Render(title) + "\n\n")
-
-	for i := range m.inputs {
-		b.WriteString(m.inputs[i].View() + "\n")
-	}
-
-	b.WriteString("\n" + helpStyle.Render("Tab to switch fields, Enter to submit, Esc to cancel"))
-	return b.String()
-}
-
-func (m *Model) resetInputs() {
-	for i := range m.inputs {
-		m.inputs[i].Reset()
-	}
-}
-
-func (m *Model) populateInputsFromSelected() {
-	if m.selected == nil {
-		return
-	}
-	m.inputs[0].SetValue(m.selected.Name)
-	m.inputs[1].SetValue(m.selected.Version)
-	m.inputs[2].SetValue(m.selected.Desc)
-	m.inputs[3].SetValue(m.selected.Type)
-	m.inputs[4].SetValue(m.selected.Source)
-}
-
-func (m Model) updateInputFocus() tea.Cmd {
-	cmds := make([]tea.Cmd, len(m.inputs))
-	for i := 0; i < len(m.inputs); i++ {
-		if i == m.focusIndex {
-			cmds[i] = m.inputs[i].Focus()
-			continue
-		}
-		m.inputs[i].Blur()
-	}
-	return tea.Batch(cmds...)
-}
-
-func (m Model) submitNewPackage() tea.Cmd {
-	return func() tea.Msg {
-		artifact := Artifact{
-			Name:    m.inputs[0].Value(),
-			Version: m.inputs[1].Value(),
-			Desc:    m.inputs[2].Value(),
-			Type:    m.inputs[3].Value(),
-			Source:  m.inputs[4].Value(),
-		}
-
-		if err := m.packageManager.AddArtifact(artifact); err != nil {
-			return errorMsg(err.Error())
-		}
-
-		m.screen = ScreenPackages
-		return successMsg("Package added successfully")
-	}
-}
-
-func (m Model) submitModifiedPackage() tea.Cmd {
-	return func() tea.Msg {
-		if m.selected == nil {
-			return errorMsg("No package selected")
-		}
-
-		updates := Artifact{
-			Name:    m.inputs[0].Value(),
-			Version: m.inputs[1].Value(),
-			Desc:    m.inputs[2].Value(),
-			Type:    m.inputs[3].Value(),
-			Source:  m.inputs[4].Value(),
-		}
-
-		if err := m.packageManager.ModifyArtifact(m.selected.Name, updates); err != nil {
-			return errorMsg(err.Error())
-		}
-
-		m.screen = ScreenPackages
-		return successMsg("Package modified successfully")
-	}
-}
-
-func (m Model) deletePackage(name string) tea.Cmd {
-	return func() tea.Msg {
-		if err := m.packageManager.RemoveArtifact(name); err != nil {
-			return errorMsg(err.Error())
-		}
-		m.screen = ScreenPackages
-		return successMsg("Package deleted successfully")
-	}
-}
-
-func (m Model) packageArtifact(name string) tea.Cmd {
-	return func() tea.Msg {
-		ctx := context.Background()
-		if err := m.packageManager.PackageArtifact(ctx, name); err != nil {
-			return errorMsg(err.Error())
-		}
-		return successMsg("Package created successfully")
-	}
-}
-
-func (m Model) unpackageArtifact(name string) tea.Cmd {
-	return func() tea.Msg {
-		ctx := context.Background()
-		if err := m.packageManager.UnpackageArtifact(ctx, name, "/tmp/unpack"); err != nil {
-			return errorMsg(err.Error())
-		}
-		return successMsg("Package unpacked successfully")
-	}
-}
-
-func main() {
-	_ = godotenv.Load()
-
-	p := tea.NewProgram(initialModel(), tea.WithAltScreen())
-	if _, err := p.Run(); err != nil {
-		fmt.Printf("Error running program: %v\n", err)
-		os.Exit(1)
-	}
-}
\ No newline at end of file