Added Require Export and LTPath Configuration options (#31)

Author: nathan-fiscaletti

README.md

@@ -3,23 +3,23 @@
 [![Sponsor Me!](https://img.shields.io/badge/%F0%9F%92%B8-Sponsor%20Me!-blue)](https://github.com/sponsors/nathan-fiscaletti)
 [![Go Report Card](https://goreportcard.com/badge/github.com/letstrygo/letstry)](https://goreportcard.com/report/github.com/letstrygo/letstry)
 
-letstry is a powerful tool designed to provide temporary work-spaces for developers, built in Golang. It allows you to quickly create new projects, save them as templates, and export them to a more permanent location.
+**letstry** is a lightweight yet powerful tool designed to give developers **templated workspaces** directly within their preferred IDE. Written in Go, it lets you spin up new projects quickly, save them as templates, and export them to a permanent location—**all from your VSCode terminal.**
 
 ## Index
 
 - [Installation](#installation)
 - [Usage](#usage)
-    - [Create a new session](#creating-a-new-session)
+    - [Configuration](#configuration)
+    - [Create a new session or project](#creating-a-new-session-or-project)
     - [Export a session](#exporting-a-session)
     - [List active sessions](#listing-active-sessions)
     - [Managing Templates](#managing-templates)
-    - [Configuration](#configuration)
 - [Contributing](#contributing)
 - [Development](#development)
 
 ## Installation
 
-Letstry requires Go to be installed on your system. If you do not have Go installed, you can download it from the [official website](https://golang.org/dl/).
+**letstry** requires Go to be installed on your system. If you do not have Go installed, you can download it from the [official website](https://golang.org/dl/).
 
 Once Go is installed, to install letstry, run the following command:
 
@@ -44,15 +44,70 @@ echo "alias lt='letstry'" >> ~/.bashrc && source ~/.bashrc
 
 ## Usage
 
-### Creating a new Session
+### Configuration
+
+> [!TIP]\
+> You can retrieve the path to the config file using the `lt path config` command. By default, the configuration is stored in `~/.letstry/config.json`.
+
+By default, letstry is set-up as a **temporary workspace manager**. This means calls to `lt new` will result in a temporary workspace being created in your systems temporary directory that will be deleted once it's associated editor window is closed. This behavior can be customized using the `projects_path` and `require_export` configuration fields.
+
+**Windows Config Example**
+
+```jsonc
+{
+    // Projects Path
+    //
+    // The path in which to store projects. By default, letstry
+    // will use a temporary directory.
+    //
+    // If no projects path is set, `require_export` will be
+    // forcibly enabled. This is the default behavior.
+    "projects_path": "",
+
+    // Require Export
+    //
+    // When true:  New projects will be created as letstry sessions.
+    //             These sessions will be automatically deleted once
+    //             the editor window is closed.
+    //
+    // When false: New projects will be stored in `projects_path`
+    //             and will be persisted after the editor window
+    //             is closed. No letstry session will be created.
+    //
+    // You can force `require_export` by passing `--temp` to `lt new`.
+    "require_export": true,
+
+    // Default Editor
+    //
+    // The default editor to use for new sessions/projects.
+    "default_editor": "vscode",
+
+    // Editors
+    //
+    // Available editors for new sessions/projects.
+    "editors": [
+        {
+            "name": "vscode",
+            "run_type": "run",
+            "path": "C:\\Users\\natef\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe",
+            "args": "-n",
+            "process_capture_delay": 2000000000,
+            "tracking_type": "file_access"
+        }
+    ]
+}
+```
 
-Creating a new session with letstry is simple and efficient. Use the `lt new` command to initialize a temporary project directory and open it in the default editor. This allows for quick prototyping. If you like the results, you can export the session to a more permanent location or save it as a template. 
+### Creating a new Session or Project
+
+Creating a new session or project with letstry is simple and efficient. Use the `lt new` command to initialize a new project or session and open it in the default editor.
 
 ```sh
 $ lt new
 ```
 
-If the VSCode window is closed, the temporary directory will be deleted. Therefore, you should either export your project using `lt export <path>` or save it as a template using `lt save <template-name>`.
+> [!IMPORTANT]
+> If `require_export` is enabled in your configuration or if you have not set a custom `projects_path`, when the VSCode window is closed the sessions temporary directory will be deleted. This is the default behavior for letstry. Therefore, you should either export your project using `lt export <path>` or save it as a template using `lt save <template-name>` (these commands must be run from within the sessions directory.)
 
 Lets try sessions can be created from a directory path, a git repository URL, or a template name.
 
@@ -124,31 +179,6 @@ To delete a template, use the `lt delete` command.
 $ lt delete <template-name>
 ```
 
-## Configuration
-
-letstry can be configured using a configuration file. The configuration file is located at `~/.letstry/config.json`.
-
-The config file allows you to specify different editors if you do not use VSCode.
-
-**Windows Config Example**
-
-`~/.letstry/config.json`
-```json
-{
-    "default_editor": "vscode",
-    "editors": [
-        {
-            "name": "vscode",
-            "run_type": "run",
-            "path": "C:\\Users\\natef\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe",
-            "args": "-n",
-            "process_capture_delay": 2000000000,
-            "tracking_type": "file_access"
-        }
-    ]
-}
-```
-
 ## Contributing
 
 We welcome contributions to improve letstry. If you have suggestions or bug reports, please open an issue or submit a pull request.

internal/application/application.go

@@ -67,6 +67,7 @@ func NewApplication(ctx context.Context) *Application {
 
 		hidden_commands.MonitorCommand(),
 		general_commands.VersionCommand(),
+		general_commands.PathCommand(),
 	}
 
 	// Initialize the application.
@@ -79,8 +80,8 @@ func NewApplication(ctx context.Context) *Application {
 			},
 
 			Name:             cli.MainName(),
-			ShortDescription: "a powerful tool for creating temporary workspaces",
-			Description:      cli.MainName() + " provides a temporary workspace for you to work in, and then destroys it when you are done.",
+			ShortDescription: "a lightweight tool designed to give developers templated workspaces",
+			Description:      cli.MainName() + " is a lightweight yet powerful tool designed to give developers templated workspaces directly within their preferred IDE. Letting you spin up new projects quickly, save them as templates, and export them to a permanent location—all from your IDEs integrated terminal.",
 		},
 	}
 

internal/application/commands/commands.go

@@ -8,6 +8,7 @@ func (c CommandName) String() string {
 
 const (
 	CommandVersion        CommandName = "version"
+	CommandPath           CommandName = "path"
 	CommandMonitor        CommandName = "monitor"
 	CommandClean          CommandName = "clean"
 	CommandPruneSessions  CommandName = "prune"

internal/application/commands/general/cmd.path.go

@@ -0,0 +1,60 @@
+package general
+
+import (
+	"context"
+
+	"github.com/letstrygo/letstry/internal/application/commands"
+	"github.com/letstrygo/letstry/internal/cli"
+	"github.com/letstrygo/letstry/internal/config"
+	"github.com/letstrygo/letstry/internal/storage"
+)
+
+func PathCommand() cli.Command {
+	return cli.Command{
+		Name:             commands.CommandPath.String(),
+		ShortDescription: "Displays paths relevant to LetsTry",
+		Description:      "Useful for locating your LetsTry config file, your LetsTry session cache file, or the directory in which LetsTry stores new sessions and projects.",
+		Arguments: []cli.Argument{
+			{
+				Name:        "file",
+				Description: "Can be one of config, projects or sessions. Defaults to \"config\".",
+			},
+		},
+		Executor: func(ctx context.Context, args []string) error {
+			cfg, err := config.GetConfig()
+			if err != nil {
+				return err
+			}
+
+			var opt string
+			if len(args) > 0 {
+				opt = args[0]
+			}
+
+			switch opt {
+			case "sessions":
+				store := storage.GetStorage()
+				sessPath := store.GetAbsolutePath("sessions.json")
+				println(sessPath)
+				return nil
+			case "projects":
+				path := cfg.LTPath
+				if cfg.RequireExport {
+					println("require-export enabled, all projects will be stored in a temporary directory and deleted once their corresponding session is terminated.")
+					return nil
+				}
+
+				if path == "" {
+					println("project-path: custom projects_path not set, all projects will be stored in a temporary directory and deleted once their corresponding session is terminated.")
+					return nil
+				}
+
+				println(cfg.LTPath)
+				return nil
+			default:
+				println(cfg.Path())
+				return nil
+			}
+		},
+	}
+}

internal/application/commands/sessions/cmd.new-session.go

@@ -13,20 +13,31 @@ import (
 func NewSessionCommand() cli.Command {
 	return cli.Command{
 		Name:             commands.CommandNewSession.String(),
-		ShortDescription: "Create a new session",
-		Description:      "Create a new session using the specified source.",
+		ShortDescription: "Create a new session or project",
+		Description:      "Create a new session or project using the specified source.",
 		Arguments: []cli.Argument{
 			{
 				Name:        "source",
-				Description: "The source to use for the new session. Can be a git repository URL, a path to a directory, or the name of a letstry template.\n\nIf source is not provided, the session will be created from a blank source.",
+				Description: "The source to use for the new session or project. Can be a git repository URL, a path to a directory, or the name of a letstry template.\n\nIf source is not provided, the session will be created from a blank source.",
+			},
+			{
+				Name:        "--temp",
+				Description: "When set, session will be forcibly stored in a temporary location. This overrides the \"Require Export\" field in your config file.",
 			},
 		},
 		Executor: func(ctx context.Context, args []string) error {
 			var source string
+			var forceRequireExport bool
 
-			if len(args) >= 1 {
+			if len(args) > 0 {
 				source = args[0]
 			}
+			if source == "--temp" {
+				source = ""
+				forceRequireExport = true
+			} else if len(args) > 1 {
+				forceRequireExport = args[1] == "--temp"
+			}
 
 			mgr, err := manager.GetManager(ctx)
 			if err != nil {
@@ -39,13 +50,18 @@ func NewSessionCommand() cli.Command {
 			}
 
 			session, err := mgr.CreateSession(ctx, manager.CreateSessionArguments{
-				Source: source,
+				Source:             source,
+				ForceRequireExport: forceRequireExport,
 			})
 			if err != nil {
 				return err
 			}
 
-			logger.Printf("session created: %s\n", session.String())
+			if session != nil {
+				logger.Printf("session created: %s\n", session.String())
+			} else {
+				logger.Printf("project created")
+			}
 
 			return nil
 		},

internal/config/config.go

@@ -7,8 +7,24 @@ import (
 )
 
 type Config struct {
+	path string
+
+	// The path at which LT projects will be placed. Defaults to your systems
+	// temporary directory.
+	LTPath string `json:"projects_path"`
+	// When enabled, projects created in letstry will be deleted after the
+	// lt session is closed (i.e. when the editor is closed).
+	//
+	// You can override this by passing `--temp` when creating the LetsTry session.
+	RequireExport bool `json:"require_export"`
+	// The name of the default editor to use for new sessions. (Default: vscode)
 	DefaultEditorName editors.EditorName `json:"default_editor"`
-	AvailableEditors  []editors.Editor   `json:"editors"`
+	// Editors available for use within LetsTry. (Default: vscode)
+	AvailableEditors []editors.Editor `json:"editors"`
+}
+
+func (cfg Config) Path() string {
+	return cfg.path
 }
 
 func (cfg Config) GetEditor(name string) (editors.Editor, error) {

internal/config/service.go

@@ -43,6 +43,8 @@ func GetConfig() (*Config, error) {
 		return nil, fmt.Errorf("failed to decode config file: %v", err)
 	}
 
+	config.path = store.GetAbsolutePath("config.json")
+
 	return config, nil
 }
 
@@ -68,6 +70,7 @@ func getDefaultConfig() *Config {
 	defaultEditor := editors.DefaultEditors()
 
 	return &Config{
+		RequireExport:     true,
 		DefaultEditorName: defaultEditor[0].Name,
 		AvailableEditors:  editors.DefaultEditors(),
 	}