.gitignore

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

README.md

@@ -1,82 +0,0 @@
-# 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,26 +11,15 @@ 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 {
-	SessionName   string   `yaml:"name"`
+	Name        string `yaml:"name"`
-	EditorCommand string   `yaml:"editor"`
+	SessionName string `yaml:"session_name"`
-	WorkingDir    string   `yaml:"root"`
+	WorkingDir  string `yaml:"working_dir"` // New field for working directory
-	Windows       []Window `yaml:"windows"`
+	Tabs        []struct {
-	LastOpened    time.Time
+		Name     string   `yaml:"name"`
-	Attach        bool   `yaml:"attach"`
+		Commands []string `yaml:"commands"`
-	StartupWindow string `yaml:"startup_window"`
+	} `yaml:"tabs"`
-	StartupPane   int    `yaml:"startup_pane"`
+	LastOpened time.Time `yaml:"last_opened"`
 }
 
 var configDir string
@@ -110,17 +99,6 @@ 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)
 
@@ -177,18 +155,39 @@ func ProjectExists(projectName string) bool {
 	return true
 }
 
-func CreateProject(sessionName, workingDir string, windows []Window) (string, error) {
+func CreateProject(projectName, sessionName, workingDir string, tabs []struct {
-	configFile := ProjectConfigFilePath(sessionName)
+	Name     string
+	Commands []string
+},
+) (string, error) {
+	configFile := ProjectConfigFilePath(projectName)
 
 	if _, err := os.Stat(configFile); err == nil {
-		return "", fmt.Errorf("Project with the name '%s' already exists", sessionName)
+		return "", fmt.Errorf("Project with the name '%s' already exists", projectName)
+	}
+
+	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,
-		Windows:     windows,
+		Tabs:        tabsWithYAMLTags,
-		Attach:      true,
+		LastOpened:  time.Now(),
 	}
 
 	err := WriteConfigToFile(configFile, newConfig)
@@ -205,10 +204,23 @@ func WriteConfigToFile(filename string, config *Configuration) error {
 		return err
 	}
 
-	err = os.WriteFile(filename, data, 0644)
+	indentedYAML := indentYAML(string(data), "") // Convert data to string
+
+	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

@@ -1,107 +0,0 @@
-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,220 +10,78 @@ 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, "-c", config.WorkingDir)
+		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
-		// createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
 		if err := createSessionCmd.Run(); err != nil {
 			return err
 		}
-		log.Debug("Ran command", "command", createSessionCmd.String())
+		log.Info("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.Debug("Ran command", "command", changeDirCmd.String())
+		log.Info("Ran command", "command", changeDirCmd.String())
 
-		// Create the first window outside the loop
+		// Send commands to the session for the first tab
-		// createWindow(config, sessionName, 0)
+		sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", sessionName, strings.Join(config.Tabs[0].Commands, " && "), "Enter")
-
-		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.Debug("Ran command", "command", sendCommandsCmd.String())
+		log.Info("Ran command", "command", sendCommandsCmd.String())
-
+		// Rename the tab to the specified name
-		// Rename the window to the specified name
+		renameTabCmd := exec.Command("tmux", "rename-window", "-t", sessionName+":1", config.Tabs[0].Name)
-		renameWindowCmd := exec.Command("tmux", "rename-window", "-t", windowName, window.WindowName)
+		if err := renameTabCmd.Run(); err != nil {
-		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
+		// Create and run commands for additional tabs
-		for j, pane := range window.Panes[1:] {
+		for i, tab := range config.Tabs[1:] {
-			paneName := fmt.Sprintf("%s:%d.%d", sessionName, 1, j+2)
+			windowName := fmt.Sprintf("%s:%d", sessionName, i+2)
-
+			createWindowCmd := exec.Command("tmux", "new-window", "-t", windowName, "-n", tab.Name)
-			// Split the window horizontally
+			if err := createWindowCmd.Run(); err != nil {
-			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())
+			log.Info("Ran command", "command", createWindowCmd.String())
 
-			// Select the new pane
+			changeDirCmd = exec.Command("tmux", "send-keys", "-t", windowName, "cd "+config.WorkingDir, "Enter")
-			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.Debug("Ran command", "command", changeDirCmd.String())
+			log.Info("Ran command", "command", changeDirCmd.String())
 
-			// Send commands to the pane
+			sendCommandsCmd = exec.Command("tmux", "send-keys", "-t", windowName, strings.Join(tab.Commands, " && "), "Enter")
-			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())
+			log.Info("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
-		defaultWindow := sessionName + ":1"
+		selectWindowCmd := exec.Command("tmux", "select-window", "-t", 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())
 
-		// Select initial pane
+		switchSessionCmd := exec.Command("tmux", "switch-client", "-t", sessionName)
-		if config.StartupPane > 0 {
+		if err := switchSessionCmd.Run(); err != nil {
-			defaultPane := fmt.Sprintf("%s:%d.%d", sessionName, config.StartupPane, 1)
+			return err
-			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,7 +12,6 @@ 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

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

@@ -1,54 +0,0 @@
-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,39 +1,64 @@
 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.ExactArgs(1),
+	Args: cobra.MaximumNArgs(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 {
@@ -46,5 +71,59 @@ func ExecuteProjectEnv(projectName string) {
 		return
 	}
 	projectconfig.UpdateLastOpened(projectName)
-	log.Debug("Created tmux session", "name", config.SessionName)
+	log.Info("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

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

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

ui/table/main.go

@@ -92,19 +92,15 @@ 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("240")).
+		Background(lipgloss.Color("57")).
 		Bold(false)
-
 	t.SetStyles(s)
 
 	m := model{t, "", help.New(), keys}

utils/editor.go

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