Added input mode to fix parsing.

Author: agnath18K

cmd/lumo/main.go

@@ -65,8 +65,46 @@ func main() {
 		}
 
 		// Process command from arguments
+		// Join arguments with spaces, preserving quotes if present
 		command := strings.Join(os.Args[1:], " ")
 
+		// In AI-first mode (default), we don't need special handling for quoted strings
+		// as everything will be treated as an AI query by default unless it has a specific prefix
+		// or is a single executable command in command-first mode.
+
+		// However, we still want to handle the case where a command might be a quoted string
+		// that was split by the shell, for better user experience
+		if len(os.Args) > 2 && !cfg.CommandFirstMode {
+			// If we have multiple arguments and none of them start with a prefix like "lumo:" or "shell:",
+			// it might be a quoted string that was split
+			hasPrefix := false
+			for _, prefix := range []string{"lumo:", "shell:", "ask:", "ai:", "auto:", "agent:",
+				"health:", "syshealth:", "report:", "sysreport:", "chat:", "talk:", "config:",
+				"speed:", "speedtest:", "speed-test:", "magic:", "clipboard", "connect"} {
+				if strings.HasPrefix(command, prefix) {
+					hasPrefix = true
+					break
+				}
+			}
+
+			if !hasPrefix {
+				// In AI-first mode, treat it as an AI query by default
+				cmd := &nlp.Command{
+					Type:       nlp.CommandTypeAI,
+					Intent:     command,
+					Parameters: make(map[string]string),
+					RawInput:   command,
+				}
+				result, err := exec.Execute(cmd)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error executing command: %v\n", err)
+					os.Exit(1)
+				}
+				term.Display(result)
+				os.Exit(0)
+			}
+		}
+
 		// Special handling for commands with specific prefixes
 		if strings.HasPrefix(command, "lumo:") || strings.HasPrefix(command, "shell:") {
 			// Handle shell commands

lumo

@@ -22,6 +22,7 @@ type Config struct {
 	MaxHistorySize           int  `json:"max_history_size"`
 	EnableLogging            bool `json:"enable_logging"`
 	EnableShellInInteractive bool `json:"enable_shell_in_interactive"`
+	CommandFirstMode         bool `json:"command_first_mode"`
 
 	// Agent mode settings
 	EnableAgentMode             bool   `json:"enable_agent_mode"`
@@ -61,6 +62,7 @@ func DefaultConfig() *Config {
 		MaxHistorySize:              1000,
 		EnableLogging:               true,
 		EnableShellInInteractive:    false,    // Shell commands disabled in interactive mode by default
+		CommandFirstMode:            false,    // Default to AI-first mode (treat input as AI queries by default)
 		EnableAgentMode:             true,     // Agent mode enabled by default
 		EnableAgentREPL:             true,     // REPL mode enabled by default
 		AgentConfirmBeforeExecution: true,     // Confirm before execution by default

pkg/config/config.go

@@ -47,6 +47,10 @@ func (e *Executor) executeConfigCommand(cmd *nlp.Command) (*Result, error) {
    • config:ollama set <url>        Set Ollama URL
    • config:ollama test             Test connection to Ollama server
 
+   • config:mode show               Show current input mode
+   • config:mode ai                 Set AI-first mode (default)
+   • config:mode command            Set command-first mode
+
 ╰──────────────────────────────────────────────────────────╯
 `,
 			IsError:    false,
@@ -64,6 +68,8 @@ func (e *Executor) executeConfigCommand(cmd *nlp.Command) (*Result, error) {
 		return e.handleKeyConfig(parts[1:], cmd)
 	case "ollama":
 		return e.handleOllamaConfig(parts[1:], cmd)
+	case "mode":
+		return e.handleModeConfig(parts[1:], cmd)
 	default:
 		return &Result{
 			Output:     fmt.Sprintf("Unknown configuration command: %s\nUse 'config:' for help.", parts[0]),
@@ -506,6 +512,91 @@ func (e *Executor) handleOllamaConfig(args []string, cmd *nlp.Command) (*Result,
 	}
 }
 
+// handleModeConfig handles input mode configuration commands
+func (e *Executor) handleModeConfig(args []string, cmd *nlp.Command) (*Result, error) {
+	if len(args) == 0 {
+		return &Result{
+			Output:     "Missing mode command. Use 'show', 'ai', or 'command'.",
+			IsError:    true,
+			CommandRun: cmd.RawInput,
+		}, nil
+	}
+
+	switch args[0] {
+	case "show":
+		// Show current mode
+		modeStr := "AI-first"
+		if e.config.CommandFirstMode {
+			modeStr = "Command-first"
+		}
+
+		output := fmt.Sprintf(`
+╭─────────────────── 🔧 Input Mode ─────────────────────────╮
+
+  Current input mode: %s
+
+  • AI-first mode: Treats all input as AI queries by default
+    unless it starts with a specific command prefix.
+
+  • Command-first mode: Treats input as shell commands if it
+    looks like a command, otherwise as an AI query.
+
+╰──────────────────────────────────────────────────────────╯
+`, modeStr)
+
+		return &Result{
+			Output:     output,
+			IsError:    false,
+			CommandRun: cmd.RawInput,
+		}, nil
+
+	case "ai":
+		// Set AI-first mode
+		e.config.CommandFirstMode = false
+
+		// Save the configuration
+		if err := e.config.Save(); err != nil {
+			return &Result{
+				Output:     fmt.Sprintf("Error saving configuration: %v", err),
+				IsError:    true,
+				CommandRun: cmd.RawInput,
+			}, nil
+		}
+
+		return &Result{
+			Output:     "Input mode set to AI-first. Lumo will now treat all input as AI queries by default unless it starts with a specific command prefix.",
+			IsError:    false,
+			CommandRun: cmd.RawInput,
+		}, nil
+
+	case "command":
+		// Set Command-first mode
+		e.config.CommandFirstMode = true
+
+		// Save the configuration
+		if err := e.config.Save(); err != nil {
+			return &Result{
+				Output:     fmt.Sprintf("Error saving configuration: %v", err),
+				IsError:    true,
+				CommandRun: cmd.RawInput,
+			}, nil
+		}
+
+		return &Result{
+			Output:     "Input mode set to Command-first. Lumo will now treat input as shell commands if it looks like a command, otherwise as an AI query.",
+			IsError:    false,
+			CommandRun: cmd.RawInput,
+		}, nil
+
+	default:
+		return &Result{
+			Output:     fmt.Sprintf("Unknown mode command: %s. Use 'show', 'ai', or 'command'.", args[0]),
+			IsError:    true,
+			CommandRun: cmd.RawInput,
+		}, nil
+	}
+}
+
 // handleKeyConfig handles API key configuration commands
 func (e *Executor) handleKeyConfig(args []string, cmd *nlp.Command) (*Result, error) {
 	if len(args) == 0 {

pkg/executor/config.go

@@ -261,6 +261,23 @@ func (e *Executor) executeShellCommand(cmd *nlp.Command) (*Result, error) {
 		}, nil
 	}
 
+	// Check if the command exists before trying to execute it
+	_, err := exec.LookPath(parts[0])
+	if err != nil {
+		// Command doesn't exist, provide a helpful error message
+		suggestion := ""
+		if len(parts) > 1 {
+			// If there are multiple words, suggest using it as an AI query
+			suggestion = fmt.Sprintf("\n\nDid you mean to ask AI about \"%s\"? Try: lumo ask:\"%s\"", cmd.Intent, cmd.Intent)
+		}
+
+		return &Result{
+			Output:     fmt.Sprintf("Error: exec: \"%s\": executable file not found in $PATH%s", parts[0], suggestion),
+			IsError:    true,
+			CommandRun: cmd.RawInput,
+		}, nil
+	}
+
 	// Create the command
 	shellCmd := exec.Command(parts[0], parts[1:]...)
 

pkg/executor/executor.go

@@ -203,24 +203,36 @@ func (p *Parser) Parse(input string) (*Command, error) {
 	// Check if this is a command-line argument (first argument is the program name)
 	args := os.Args
 	if len(args) > 1 && input == strings.Join(args[1:], " ") {
-		// Check if the input looks like a natural language query
-		// Natural language queries typically:
-		// 1. Start with a capital letter (questions, sentences)
-		// 2. Contain multiple words with spaces
-		// 3. End with a question mark (for questions)
-		// 4. Don't contain shell command special characters like |, >, <, etc.
-
-		// If it looks like a natural language query, treat it as an AI query
-		if isNaturalLanguageQuery(input) {
-			cmd.Type = CommandTypeAI
+		// Split the input into words
+		words := strings.Fields(input)
+
+		// Check if it's a single word that exists as an executable in PATH
+		if len(words) == 1 {
+			_, err := exec.LookPath(words[0])
+			if err == nil && p.config.CommandFirstMode {
+				// It's a single word that exists as a command and we're in command-first mode
+				cmd.Type = CommandTypeShell
+				cmd.Intent = input
+				return cmd, nil
+			}
+		}
+
+		// If we're in command-first mode, check if it looks like a natural language query
+		if p.config.CommandFirstMode {
+			// If it looks like a natural language query, treat it as an AI query
+			if IsNaturalLanguageQuery(input) {
+				cmd.Type = CommandTypeAI
+				cmd.Intent = input
+				return cmd, nil
+			}
+
+			// Otherwise, treat it as a shell command in command-first mode
+			cmd.Type = CommandTypeShell
 			cmd.Intent = input
 			return cmd, nil
 		}
 
-		// Otherwise, treat it as a shell command
-		cmd.Type = CommandTypeShell
-		cmd.Intent = input
-		return cmd, nil
+		// In AI-first mode (default), we treat everything as AI query unless it's a specific exception
 	}
 
 	// Check if this looks like a speed test query
@@ -230,7 +242,7 @@ func (p *Parser) Parse(input string) (*Command, error) {
 		return cmd, nil
 	}
 
-	// Check if this looks like a task that should use agent mode
+	// In AI-first mode, check if this looks like a task that should use agent mode
 	if isAgentTask(input) && p.config.EnableAgentMode {
 		cmd.Type = CommandTypeAgent
 		cmd.Intent = input
@@ -243,9 +255,9 @@ func (p *Parser) Parse(input string) (*Command, error) {
 	return cmd, nil
 }
 
-// isNaturalLanguageQuery determines if a string is likely to be a natural language query
-// rather than a shell command
-func isNaturalLanguageQuery(input string) bool {
+// IsNaturalLanguageQuery determines if a string is likely to be a natural language query
+// rather than a shell command. This is exported for use in other packages.
+func IsNaturalLanguageQuery(input string) bool {
 	// Trim the input
 	input = strings.TrimSpace(input)
 
@@ -305,6 +317,22 @@ func isNaturalLanguageQuery(input string) bool {
 		}
 	}
 
+	// Check for common action verbs that are likely part of natural language queries
+	// but might be confused with shell commands
+	actionVerbs := []string{"create", "find", "list", "show", "get", "make", "setup", "install",
+		"configure", "backup", "search", "organize", "clean", "delete", "remove", "update", "check", "analyze"}
+
+	if len(words) > 1 {
+		firstWord := strings.ToLower(words[0])
+		for _, verb := range actionVerbs {
+			if firstWord == verb {
+				// If it's an action verb followed by at least one more word, it's likely a natural language query
+				// e.g., "create folder" is a natural language query, not a shell command
+				return true
+			}
+		}
+	}
+
 	// Check if the input is a single word that doesn't exist as a command
 	// This is a heuristic to prevent treating unknown commands as shell commands
 	if len(words) == 1 {