Update README.md

some configs from tmuxinator not yet supported so will remove them for now until we can support it

.gitignore

@@ -0,0 +1 @@
+.obsidian

README.md

@@ -0,0 +1,82 @@
+# Pee
+
+Project Environment Executor, Define your project workspace as code and config.
+
+## Usecase
+Creating tmux sessions with preconfigured panes layouts and commands. inspired from [tmuxinator](https://github.com/tmuxinator/tmuxinator)
+
+### Get Started
+
+![Screen Recording 2023-10-22 at 2 11 11 PM](https://github.com/xrehpicx/pee/assets/22765674/b355da63-1e2d-4833-8300-1bd879e2245f)
+
+#### Installation
+```bash
+go install github.com/xrehpicx/pee.git@latest
+```
+
+#### Initialize a project
+```bash
+pee init myproject
+```
+Select a directory from the file picker by `<space>`, the directory that the init is run in will be the default starting directory for the file picker, you can go up and down directories by `<backspace>` and `<enter>`
+
+#### Configure project
+Config is similar to [tmuxinator](https://github.com/tmuxinator/tmuxinator)
+```yml
+name: ppec-ui
+editor: nvim
+root: /Users/raj.sharma/Documents/GitHub/ppec-ui
+windows:
+  - window_name: editor
+    layout: 8070,202x58,0,0[202x46,0,0,89,202x11,0,47,92]
+    panes:
+      - shell_command:
+          - nvim "+SessionManager load_current_dir_session"
+      - shell_command:
+          - echo 'npm run dev'
+  - window_name: hosts
+    layout: even-horizontal
+    shell_command_before:
+      - cd somewhere && activate env
+    panes:
+      - shell_command:
+          - ssh stg-host1
+      - shell_command:
+          - ssh stg-host2
+  - window_name: git
+    panes:
+      - shell_command:
+          - lazygit
+lastopened: 2023-10-22T14:03:54.071678+05:30
+attach: true
+```
+editor here is used as the default editor for editing the config file.
+`note: attach here does not tmux attach the new session, instead uses tmux switch-client for faster switching.`
+
+#### Run a project
+For this example we have a project called ppec with the above config
+```bash
+pee ppec
+```
+and this should open up ppec tmux session
+
+#### Edit or Run from list
+![Screen Recording 2023-10-22 at 2 12 41 PM](https://github.com/xrehpicx/pee/assets/22765674/f8bb6c1d-1a68-4194-8c4c-62ff4856cd2c)
+
+You can also run
+```bash
+pee ls
+```
+and select the project from table and click `<enter>` to open/create the session or `<e>` to edit the config of the project 
+
+### Roadmap
+1. Supporting iTerm2
+   As of now this supports only tmux windows and panes, would want to add support for iterm and other terminals if they have api's to do so.
+2. Ability to save an opened session into a config or update a config
+3. Parse cli args to config
+4. Ability to save custom layouts as named layouts that can be used across multiple projects
+5. Sync configs across devices
+
+---
+All contributions are welcome 
+

config/main.go

@@ -11,15 +11,26 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+type Pane struct {
+	ShellCommand []string `yaml:"shell_command"`
+}
+
+type Window struct {
+	WindowName         string   `yaml:"window_name"`
+	Layout             string   `yaml:"layout"`
+	ShellCommandBefore []string `yaml:"shell_command_before"`
+	Panes              []Pane   `yaml:"panes"`
+}
+
 type Configuration struct {
-	Name        string `yaml:"name"`
+	SessionName   string   `yaml:"name"`
-	SessionName string `yaml:"session_name"`
+	EditorCommand string   `yaml:"editor"`
-	WorkingDir  string `yaml:"working_dir"` // New field for working directory
+	WorkingDir    string   `yaml:"root"`
-	Tabs        []struct {
+	Windows       []Window `yaml:"windows"`
-		Name     string   `yaml:"name"`
+	LastOpened    time.Time
-		Commands []string `yaml:"commands"`
+	Attach        bool   `yaml:"attach"`
-	} `yaml:"tabs"`
+	StartupWindow string `yaml:"startup_window"`
-	LastOpened time.Time `yaml:"last_opened"`
+	StartupPane   int    `yaml:"startup_pane"`
 }
 
 var configDir string
@@ -99,6 +110,17 @@ func UpdateLastOpened(projectName string) error {
 	return nil
 }
 
+func GetEditorCommand(projectName string) (string, error) {
+	configFile := ProjectConfigFilePath(projectName)
+
+	config, err := Load(configFile)
+	if err != nil {
+		return "", err
+	}
+
+	return config.EditorCommand, nil
+}
+
 func ListProjects() (map[string]*Configuration, error) {
 	projectConfigs := make(map[string]*Configuration)
 
@@ -155,39 +177,18 @@ func ProjectExists(projectName string) bool {
 	return true
 }
 
-func CreateProject(projectName, sessionName, workingDir string, tabs []struct {
+func CreateProject(sessionName, workingDir string, windows []Window) (string, error) {
-	Name     string
+	configFile := ProjectConfigFilePath(sessionName)
-	Commands []string
-},
-) (string, error) {
-	configFile := ProjectConfigFilePath(projectName)
 
 	if _, err := os.Stat(configFile); err == nil {
-		return "", fmt.Errorf("Project with the name '%s' already exists", projectName)
+		return "", fmt.Errorf("Project with the name '%s' already exists", sessionName)
-	}
-
-	var tabsWithYAMLTags []struct {
-		Name     string   `yaml:"name"`
-		Commands []string `yaml:"commands"`
-	}
-
-	for _, tab := range tabs {
-		tabWithYAMLTags := struct {
-			Name     string   `yaml:"name"`
-			Commands []string `yaml:"commands"`
-		}{
-			Name:     tab.Name,
-			Commands: tab.Commands,
-		}
-		tabsWithYAMLTags = append(tabsWithYAMLTags, tabWithYAMLTags)
 	}
 
 	newConfig := &Configuration{
-		Name:        projectName,
 		SessionName: sessionName,
 		WorkingDir:  workingDir,
-		Tabs:        tabsWithYAMLTags,
+		Windows:     windows,
-		LastOpened:  time.Now(),
+		Attach:      true,
 	}
 
 	err := WriteConfigToFile(configFile, newConfig)
@@ -204,23 +205,10 @@ func WriteConfigToFile(filename string, config *Configuration) error {
 		return err
 	}
 
-	indentedYAML := indentYAML(string(data), "") // Convert data to string
+	err = os.WriteFile(filename, data, 0644)
-
-	err = os.WriteFile(filename, []byte(indentedYAML), 0644)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
-
-func indentYAML(yamlString, prefix string) string {
-	lines := strings.Split(yamlString, "\n")
-	indentedLines := make([]string, len(lines))
-
-	for i, line := range lines {
-		indentedLines[i] = prefix + line
-	}
-
-	return strings.Join(indentedLines, "\n")
-}

controller/screen.go

@@ -0,0 +1,107 @@
+package controller
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/charmbracelet/log"
+	projectconfig "github.com/xrehpicx/pee/config"
+)
+
+// RunShellCommand executes a shell command and logs it.
+func RunShellCommand(cmd *exec.Cmd) error {
+	log.Debug("Running command:", "command", cmd.String())
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Error("Error running command:", "command", cmd.String(), "error", err)
+		log.Info("Command output:", "output", string(output))
+		return err
+	}
+	return nil
+}
+
+// CreateScreenSession creates a new screen session based on the given Configuration.
+func CreateScreenSession(config *projectconfig.Configuration) error {
+	sessionName := config.SessionName
+
+	// Check if the session already exists
+	checkSessionCmd := exec.Command("screen", "-S", sessionName, "-Q", "windows")
+	_, err := checkSessionCmd.CombinedOutput()
+	if err == nil {
+		// If it exists, attach to the session
+		attachSessionCmd := exec.Command("screen", "-d", "-r", sessionName)
+		RunShellCommand(attachSessionCmd)
+	} else {
+		// If it doesn't exist, create the session
+		createSessionCmd := exec.Command("screen", "-S", sessionName, "-d", "-m")
+		RunShellCommand(createSessionCmd)
+
+		// Create and run commands for windows
+		for i, window := range config.Windows {
+			windowName := fmt.Sprintf("%s-%d", sessionName, i+1)
+
+			// Create a new window within the session
+			createWindowCmd := exec.Command("screen", "-S", sessionName, "-X", "screen", "-t", windowName)
+			RunShellCommand(createWindowCmd)
+
+			// Change the working directory for the window
+			changeDirCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "chdir", config.WorkingDir)
+			RunShellCommand(changeDirCmd)
+
+			// Send commands to the window
+			sendCommandsCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "stuff", strings.Join(window.Panes[0].ShellCommand, " && ")+"\n")
+			RunShellCommand(sendCommandsCmd)
+
+			// Rename the window to the specified name
+			renameWindowCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "title", window.WindowName)
+			RunShellCommand(renameWindowCmd)
+
+			// warn user of compatibility issues using more than one pane with screen
+			if len(window.Panes) > 1 {
+				log.Warn("Screen does not support multiple panes. Only the first pane will be used.")
+			}
+
+			// Create and run commands for additional panes in the window
+			for _, pane := range window.Panes[1:] {
+				// Split the window vertically
+				splitPaneCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "split")
+				RunShellCommand(splitPaneCmd)
+
+				// Select the new pane
+				selectPaneCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i+1)) // Select the next pane
+				RunShellCommand(selectPaneCmd)
+
+				// Send commands to the new pane
+				sendCommandsCmd := exec.Command("screen", "-S", sessionName, "-X", "stuff", strings.Join(pane.ShellCommand, " && ")+"\n")
+				RunShellCommand(sendCommandsCmd)
+			}
+
+			if window.Layout != "" {
+				layoutCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "layout", window.Layout)
+				RunShellCommand(layoutCmd)
+			}
+		}
+
+		if config.Attach {
+			// Attach to the session
+			attachSessionCmd := exec.Command("screen", "-d", "-r", sessionName)
+			RunShellCommand(attachSessionCmd)
+		}
+	}
+
+	return nil
+}
+
+// KillScreenSession kills a screen session by name.
+func KillScreenSession(sessionName string) error {
+	// Kill the screen session
+	killSessionCmd := exec.Command("screen", "-S", sessionName, "-X", "quit")
+	err := killSessionCmd.Run()
+	if err != nil {
+		log.Error("Error killing screen session:", "sessionName", sessionName, "error", err)
+		return err
+	}
+	log.Info("Killed screen session:", "sessionName", sessionName)
+	return nil
+}

controller/tmux.go

@@ -10,78 +10,220 @@ import (
 	"github.com/charmbracelet/log"
 )
 
-// CreateTmuxSession creates a tmux session based on the given Configuration.
+// CreateTmuxSession creates a Tmux session based on the given Configuration.
 func CreateTmuxSession(config *projectconfig.Configuration) error {
 	sessionName := config.SessionName
 
 	// Check if the session exists
 	checkSessionCmd := exec.Command("tmux", "has-session", "-t", sessionName)
+	log.Debug("Ran command", "command", checkSessionCmd.String())
 	if err := checkSessionCmd.Run(); err == nil {
 		// If it exists, switch to the session
 		switchSessionCmd := exec.Command("tmux", "switch-client", "-t", sessionName)
 		if err := switchSessionCmd.Run(); err != nil {
 			return err
 		}
+		log.Debug("Ran command", "command", switchSessionCmd.String())
 	} else {
 		// If it doesn't exist, create the session
-		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
+		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName, "-c", config.WorkingDir)
+		// createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
 		if err := createSessionCmd.Run(); err != nil {
 			return err
 		}
-		log.Info("Ran command", "command", createSessionCmd.String())
+		log.Debug("Ran command", "command", createSessionCmd.String())
 
 		// Change the working directory
 		changeDirCmd := exec.Command("tmux", "send-keys", "-t", sessionName, "cd "+config.WorkingDir, "Enter")
 		if err := changeDirCmd.Run(); err != nil {
 			return err
 		}
-		log.Info("Ran command", "command", changeDirCmd.String())
+		log.Debug("Ran command", "command", changeDirCmd.String())
 
-		// Send commands to the session for the first tab
+		// Create the first window outside the loop
-		sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", sessionName, strings.Join(config.Tabs[0].Commands, " && "), "Enter")
+		// createWindow(config, sessionName, 0)
+
+		window := config.Windows[0]
+		windowName := fmt.Sprintf("%s:%d", sessionName, 1)
+
+		sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", windowName, strings.Join(window.Panes[0].ShellCommand, " && "), "Enter")
 		if err := sendCommandsCmd.Run(); err != nil {
 			return err
 		}
-		log.Info("Ran command", "command", sendCommandsCmd.String())
+		log.Debug("Ran command", "command", sendCommandsCmd.String())
-		// Rename the tab to the specified name
+
-		renameTabCmd := exec.Command("tmux", "rename-window", "-t", sessionName+":1", config.Tabs[0].Name)
+		// Rename the window to the specified name
-		if err := renameTabCmd.Run(); err != nil {
+		renameWindowCmd := exec.Command("tmux", "rename-window", "-t", windowName, window.WindowName)
+		if err := renameWindowCmd.Run(); err != nil {
 			return err
 		}
+		log.Debug("Ran command", "command", renameWindowCmd.String())
 
-		// Create and run commands for additional tabs
+		// Create and run commands for additional panes in the window
-		for i, tab := range config.Tabs[1:] {
+		for j, pane := range window.Panes[1:] {
-			windowName := fmt.Sprintf("%s:%d", sessionName, i+2)
+			paneName := fmt.Sprintf("%s:%d.%d", sessionName, 1, j+2)
-			createWindowCmd := exec.Command("tmux", "new-window", "-t", windowName, "-n", tab.Name)
+
-			if err := createWindowCmd.Run(); err != nil {
+			// Split the window horizontally
+			splitPaneCmd := exec.Command("tmux", "split-window", "-t", windowName, "-h", "-p", "50")
+			if err := splitPaneCmd.Run(); err != nil {
 				return err
 			}
-			log.Info("Ran command", "command", createWindowCmd.String())
+			log.Debug("Ran command", "command", splitPaneCmd.String())
 
-			changeDirCmd = exec.Command("tmux", "send-keys", "-t", windowName, "cd "+config.WorkingDir, "Enter")
+			// Select the new pane
+			selectPaneCmd := exec.Command("tmux", "select-pane", "-t", paneName)
+			if err := selectPaneCmd.Run(); err != nil {
+				return err
+			}
+			log.Debug("Ran command", "command", selectPaneCmd.String())
+
+			// Change the working directory
+			changeDirCmd := exec.Command("tmux", "send-keys", "-t", paneName, "cd "+config.WorkingDir, "Enter")
 			if err := changeDirCmd.Run(); err != nil {
 				return err
 			}
-			log.Info("Ran command", "command", changeDirCmd.String())
+			log.Debug("Ran command", "command", changeDirCmd.String())
 
-			sendCommandsCmd = exec.Command("tmux", "send-keys", "-t", windowName, strings.Join(tab.Commands, " && "), "Enter")
+			// Send commands to the pane
+			sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", paneName, strings.Join(pane.ShellCommand, " && "), "Enter")
 			if err := sendCommandsCmd.Run(); err != nil {
 				return err
 			}
-			log.Info("Ran command", "command", sendCommandsCmd.String())
+			log.Debug("Ran command", "command", sendCommandsCmd.String())
+		}
+
+		if window.Layout != "" {
+			layoutCmd := exec.Command("tmux", "select-layout", "-t", windowName, window.Layout)
+			if err := layoutCmd.Run(); err != nil {
+				return err
+			}
+			log.Debug("Ran command", "command", layoutCmd.String())
+		}
+
+		// Create and run commands for each window inside the loop
+		for i := 1; i < len(config.Windows); i++ {
+			createWindow(config, sessionName, i)
 		}
 
 		// Select the initial window and switch to the session
-		selectWindowCmd := exec.Command("tmux", "select-window", "-t", sessionName+":1")
+		defaultWindow := sessionName + ":1"
+		if config.StartupWindow != "" {
+			defaultWindow = config.StartupWindow
+		}
+
+		selectWindowCmd := exec.Command("tmux", "select-window", "-t", defaultWindow)
 		if err := selectWindowCmd.Run(); err != nil {
 			return err
 		}
+		log.Debug("Ran command", "command", selectWindowCmd.String())
 
-		switchSessionCmd := exec.Command("tmux", "switch-client", "-t", sessionName)
+		// Select initial pane
-		if err := switchSessionCmd.Run(); err != nil {
+		if config.StartupPane > 0 {
-			return err
+			defaultPane := fmt.Sprintf("%s:%d.%d", sessionName, config.StartupPane, 1)
+			selectPaneCmd := exec.Command("tmux", "select-pane", "-t", defaultPane)
+			if err := selectPaneCmd.Run(); err != nil {
+				return err
+			}
+			log.Debug("Ran command", "command", selectPaneCmd.String())
+		}
+
+		if config.Attach {
+			switchSessionCmd := exec.Command("tmux", "switch-client", "-t", sessionName)
+			if err := switchSessionCmd.Run(); err != nil {
+				return err
+			}
+			log.Debug("Ran command", "command", switchSessionCmd.String())
 		}
 	}
 
 	return nil
 }
+
+func createWindow(config *projectconfig.Configuration, sessionName string, index int) error {
+	if index >= len(config.Windows) {
+		return nil
+	}
+	window := config.Windows[index]
+	windowName := fmt.Sprintf("%s:%d", sessionName, index+1)
+
+	// Create a new window
+	createWindowCmd := exec.Command("tmux", "new-window", "-t", sessionName, "-n", windowName)
+	if err := createWindowCmd.Run(); err != nil {
+		return err
+	}
+	log.Debug("Ran command", "command", createWindowCmd.String())
+
+	// Change the working directory for the window
+	changeDirCmd := exec.Command("tmux", "send-keys", "-t", windowName, "cd "+config.WorkingDir, "Enter")
+	if err := changeDirCmd.Run(); err != nil {
+		return err
+	}
+	log.Debug("Ran command", "command", changeDirCmd.String())
+
+	// Send commands to the window
+	sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", windowName, strings.Join(window.Panes[0].ShellCommand, " && "), "Enter")
+	if err := sendCommandsCmd.Run(); err != nil {
+		return err
+	}
+	log.Debug("Ran command", "command", sendCommandsCmd.String())
+
+	// Rename the window to the specified name
+	renameWindowCmd := exec.Command("tmux", "rename-window", "-t", windowName, window.WindowName)
+	if err := renameWindowCmd.Run(); err != nil {
+		return err
+	}
+	log.Debug("Ran command", "command", renameWindowCmd.String())
+
+	// Create and run commands for additional panes in the window
+	for j, pane := range window.Panes[1:] {
+		paneName := fmt.Sprintf("%s:%d.%d", sessionName, index+1, j+2)
+
+		// Split the window horizontally
+		splitPaneCmd := exec.Command("tmux", "split-window", "-t", windowName, "-h", "-p", "50")
+		if err := splitPaneCmd.Run(); err != nil {
+			return err
+		}
+		log.Debug("Ran command", "command", splitPaneCmd.String())
+
+		// Select the new pane
+		selectPaneCmd := exec.Command("tmux", "select-pane", "-t", paneName)
+		if err := selectPaneCmd.Run(); err != nil {
+			return err
+		}
+		log.Debug("Ran command", "command", selectPaneCmd.String())
+
+		// Change the working directory for the pane
+		changeDirCmd := exec.Command("tmux", "send-keys", "-t", paneName, "cd "+config.WorkingDir, "Enter")
+		if err := changeDirCmd.Run(); err != nil {
+			return err
+		}
+		log.Debug("Ran command", "command", changeDirCmd.String())
+
+		// Send commands to the pane
+		sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", paneName, strings.Join(pane.ShellCommand, " && "), "Enter")
+		if err := sendCommandsCmd.Run(); err != nil {
+			return err
+		}
+		log.Debug("Ran command", "command", sendCommandsCmd.String())
+	}
+
+	if window.Layout != "" {
+
+		layoutCmd := exec.Command("tmux", "select-layout", "-t", windowName, window.Layout)
+		if err := layoutCmd.Run(); err != nil {
+			return err
+		}
+		log.Debug("Ran command", "command", layoutCmd.String())
+	}
+
+	return nil
+}
+
+func KillTmuxSession(sessionName string) error {
+	killSessionCmd := exec.Command("tmux", "kill-session", "-t", sessionName)
+	if err := killSessionCmd.Run(); err != nil {
+		return err
+	}
+	log.Debug("Ran command", "command", killSessionCmd.String())
+	return nil
+}

main.go

@@ -12,6 +12,7 @@ func init() {
 	projectconfig.Init()
 	projectmanager.RootCmd.AddCommand(projectmanager.ListProjects)
 	projectmanager.RootCmd.AddCommand(projectmanager.InitCmd)
+	projectmanager.RootCmd.AddCommand(projectmanager.ScreenCmd)
 }
 
 func main() {

project-manager/init.go

@@ -0,0 +1,92 @@
+package projectmanager
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/charmbracelet/log"
+	"github.com/spf13/cobra"
+	projectconfig "github.com/xrehpicx/pee/config"
+	"github.com/xrehpicx/pee/ui/filepicker"
+	"github.com/xrehpicx/pee/utils"
+)
+
+var InitCmd = &cobra.Command{
+	Use:  "init",
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		projectName := args[0]
+		projectExists := projectconfig.ProjectExists(projectName)
+		if projectExists {
+			log.Warn("Project already exists", "name", projectName)
+			return
+		}
+
+		selected, err := filepicker.FilePicker("Select your project dir", "Selected Dir: ")
+		if selected == "" {
+			log.Warn("No dir selected, aborting")
+			return
+		}
+		if err != nil {
+			log.Error(err)
+			return
+		}
+		log.Debug("Selected", "work_dir", selected)
+
+		// Define the session configuration
+		workingDir := selected
+		windows := []projectconfig.Window{
+			{
+				WindowName: "editor",
+				Layout:     "8070,202x58,0,0[202x46,0,0,89,202x11,0,47,92]",
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your editor'"},
+					},
+					{
+						ShellCommand: []string{"echo 'run dev server'"},
+					},
+				},
+			},
+			{
+				WindowName: "ssh windows",
+				ShellCommandBefore: []string{
+					"ls -lr",
+				},
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your ssh windows'"},
+					},
+					{
+						ShellCommand: []string{"echo 'command to open your ssh windows'"},
+					},
+				},
+			},
+			{
+				WindowName: "git",
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your git client'"},
+					},
+				},
+			},
+		}
+
+		logger := log.NewWithOptions(os.Stderr, log.Options{
+			ReportCaller:    false,
+			ReportTimestamp: false,
+		})
+
+		ppath, err := projectconfig.CreateProject(projectName, workingDir, windows)
+		if err != nil {
+			logger.Error(err)
+		} else {
+			editorCommand, err := projectconfig.GetEditorCommand(projectName)
+			if err != nil {
+				editorCommand = ""
+			}
+			utils.EditFile(ppath, editorCommand)
+			fmt.Println("Created Project, config is at:", ppath)
+		}
+	},
+}

project-manager/ls.go

@@ -0,0 +1,54 @@
+package projectmanager
+
+import (
+	"fmt"
+
+	btable "github.com/charmbracelet/bubbles/table"
+	"github.com/charmbracelet/log"
+	"github.com/spf13/cobra"
+	projectconfig "github.com/xrehpicx/pee/config"
+	"github.com/xrehpicx/pee/ui/table"
+	"github.com/xrehpicx/pee/utils"
+)
+
+var ListProjects = &cobra.Command{
+	Use:   "ls",
+	Short: "List all projects",
+	Run: func(cmd *cobra.Command, args []string) {
+		projects, err := projectconfig.ListProjects()
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		columns := []btable.Column{
+			{Title: "Name", Width: 20},
+			{Title: "Session Name", Width: 20},
+			{Title: "Working Dir", Width: 50},
+			{Title: "Last Opened", Width: 20},
+		}
+		var rows []btable.Row
+
+		for projectName, config := range projects {
+			row := []string{
+				projectName,
+				config.SessionName,
+				config.WorkingDir,
+				config.LastOpened.Format("2006-01-02 15:04:05"),
+			}
+			rows = append(rows, row)
+		}
+		selectedRow, action := table.Table(columns, rows)
+		if action == "edit" {
+			// print a vim command to open the config file
+			editorCommand, err := projectconfig.GetEditorCommand(selectedRow[0])
+			if err != nil {
+				editorCommand = ""
+			}
+			utils.EditFile(projectconfig.ProjectConfigFilePath(selectedRow[0]), editorCommand)
+			log.Debug("Opened config file", "file", projectconfig.ProjectConfigFilePath(selectedRow[0]))
+		}
+		if action == "open" {
+			ExecuteProjectEnv(selectedRow[0])
+		}
+	},
+}

project-manager/main.go

@@ -1,64 +1,39 @@
 package projectmanager
 
 import (
-	"fmt"
-	"os"
-
 	projectconfig "github.com/xrehpicx/pee/config"
 	"github.com/xrehpicx/pee/controller"
-	"github.com/xrehpicx/pee/ui/filepicker"
-	"github.com/xrehpicx/pee/ui/table"
 
-	btable "github.com/charmbracelet/bubbles/table"
 	"github.com/charmbracelet/log"
 	"github.com/spf13/cobra"
 )
 
-var ListProjects = &cobra.Command{
-	Use:   "ls",
-	Short: "List all projects",
-	Run: func(cmd *cobra.Command, args []string) {
-		projects, err := projectconfig.ListProjects()
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		columns := []btable.Column{
-			{Title: "Name", Width: 20},
-			{Title: "Session Name", Width: 20},
-			{Title: "Working Dir", Width: 50},
-			{Title: "Last Opened", Width: 20},
-		}
-		var rows []btable.Row
-
-		for projectName, config := range projects {
-			row := []string{
-				projectName,
-				config.SessionName,
-				config.WorkingDir,
-				config.LastOpened.Format("2006-01-02 15:04:05"),
-			}
-			rows = append(rows, row)
-		}
-		selectedRow, action := table.Table(columns, rows)
-		if action == "edit" {
-			// print a vim command to open the config file
-			fmt.Println("vim", projectconfig.ProjectConfigFilePath(selectedRow[0]))
-		}
-		if action == "open" {
-			ExecuteProjectEnv(selectedRow[0])
-		}
-	},
-}
-
 var RootCmd = &cobra.Command{
 	Use:  "pee",
-	Args: cobra.MaximumNArgs(1),
+	Args: cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		ExecuteProjectEnv(args[0])
 	},
 }
 
+var KillTmuxSessionCmd = &cobra.Command{
+	Use:  "kill",
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		sessionName := args[0]
+		err := controller.KillTmuxSession(sessionName)
+		if err != nil {
+			log.Error(err)
+			return
+		}
+		log.Debug("Killed tmux session", "name", sessionName)
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(KillTmuxSessionCmd)
+}
+
 func ExecuteProjectEnv(projectName string) {
 	config, err := projectconfig.GetProjectConfig(projectName)
 	if err != nil {
@@ -71,59 +46,5 @@ func ExecuteProjectEnv(projectName string) {
 		return
 	}
 	projectconfig.UpdateLastOpened(projectName)
-	log.Info("Created tmux session", "name", config.SessionName)
+	log.Debug("Created tmux session", "name", config.SessionName)
-}
-
-var InitCmd = &cobra.Command{
-	Use:  "init",
-	Args: cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		projectName := args[0]
-		projectExists := projectconfig.ProjectExists(projectName)
-		if projectExists {
-			log.Warn("Project already exists", "name", projectName)
-			return
-		}
-
-		selected, err := filepicker.FilePicker("Select your project dir", "Selected Dir: ")
-		if selected == "" {
-			log.Warn("No dir selected, aborting")
-			return
-		}
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		log.Info("Selected", "work_dir", selected)
-
-		sessionName := projectName
-		tabs := []struct {
-			Name     string
-			Commands []string
-		}{
-			{
-				Name:     "editor",
-				Commands: []string{"echo 'command to open ur editor'"},
-			},
-			{
-				Name:     "dev server",
-				Commands: []string{"echo 'command to start dev server'", "echo 'command to just initialize ur dependencies'"},
-			},
-			{
-				Name:     "git",
-				Commands: []string{"echo 'command to open ur git client (use lazygit its amazing)'"},
-			},
-		}
-		logger := log.NewWithOptions(os.Stderr, log.Options{
-			ReportCaller:    false,
-			ReportTimestamp: false,
-		})
-		ppath, err := projectconfig.CreateProject(projectName, sessionName, selected, tabs)
-		if err != nil {
-			logger.Error(err)
-		} else {
-			// logger.Info("Created Project", "path", ppath)
-			fmt.Println("Created Project", "setup your config by editing: ", ppath)
-		}
-	},
 }

project-manager/screen.go

@@ -0,0 +1,43 @@
+package projectmanager
+
+import (
+	"github.com/charmbracelet/log"
+	"github.com/spf13/cobra"
+	projectconfig "github.com/xrehpicx/pee/config"
+	"github.com/xrehpicx/pee/controller"
+)
+
+var KillScreenCmd = &cobra.Command{
+	Use:  "kill",
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		controller.KillScreenSession(args[0])
+	},
+}
+
+var ScreenCmd = &cobra.Command{
+	Use:  "scr",
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		ExecuteProjectEnvUsingScreen(args[0])
+	},
+}
+
+func ExecuteProjectEnvUsingScreen(projectName string) {
+	config, err := projectconfig.GetProjectConfig(projectName)
+	if err != nil {
+		log.Error(err)
+		return
+	}
+	err = controller.CreateScreenSession(config)
+	if err != nil {
+		log.Error(err)
+		return
+	}
+	projectconfig.UpdateLastOpened(projectName)
+	log.Debug("Created tmux session", "name", config.SessionName)
+}
+
+func init() {
+	ScreenCmd.AddCommand(KillScreenCmd)
+}

readme.md

@@ -1 +0,0 @@
-# Project Environment Executor

ui/table/main.go

@@ -92,15 +92,19 @@ func Table(columns []table.Column, rows []table.Row) (table.Row, string) {
 	)
 
 	s := table.DefaultStyles()
+
+	// rounded borders
 	s.Header = s.Header.
 		BorderStyle(lipgloss.NormalBorder()).
 		BorderForeground(lipgloss.Color("240")).
 		BorderBottom(true).
 		Bold(false)
+
 	s.Selected = s.Selected.
 		Foreground(lipgloss.Color("229")).
-		Background(lipgloss.Color("57")).
+		Background(lipgloss.Color("240")).
 		Bold(false)
+
 	t.SetStyles(s)
 
 	m := model{t, "", help.New(), keys}

utils/editor.go

@@ -0,0 +1,34 @@
+package utils
+
+import (
+	"os"
+	"os/exec"
+)
+
+func checkNvimExists() bool {
+	cmd := exec.Command("nvim", "--version")
+	err := cmd.Run()
+	return err == nil
+}
+
+func EditFile(filePath string, editorCommand string) error {
+	if editorCommand == "" {
+		if checkNvimExists() {
+			editorCommand = "nvim"
+		} else {
+			editorCommand = "vim"
+		}
+	}
+
+	cmd := exec.Command(editorCommand, filePath)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}