centaurus-cli 3.0.0 → 3.1.0

package/dist/commands/CommandParser.js

@@ -1,336 +1,393 @@
-/**
- * Command Parser
- * Handles parsing and routing of slash commands
- */
-export class CommandParser {
-    commands = new Map();
-    constructor() {
-        this.registerDefaultCommands();
-    }
-    registerDefaultCommands() {
-        // Register built-in commands
-        this.register({
-            name: 'help',
-            description: 'Show available commands',
-            aliases: ['h', '?'],
-            execute: async () => ({
-                success: true,
-                action: 'show-help',
-                data: this.getHelp()
-            })
-        });
-        this.register({
-            name: 'model',
-            description: 'Select AI model',
-            aliases: ['m'],
-            execute: async (args) => {
-                if (args.length > 0) {
-                    // Direct model selection
-                    return {
-                        success: true,
-                        data: { model: args.join(' ') }
-                    };
-                }
-                // Show model picker
-                return {
-                    success: true,
-                    action: 'show-model-picker'
-                };
-            }
-        });
-        this.register({
-            name: 'config',
-            description: 'View or edit configuration',
-            aliases: ['c', 'settings'],
-            execute: async (args) => {
-                if (args.length === 0) {
-                    return {
-                        success: true,
-                        action: 'show-config'
-                    };
-                }
-                // Handle config set command
-                if (args[0] === 'set' && args.length >= 3) {
-                    const key = args[1];
-                    const value = args.slice(2).join(' ');
-                    return {
-                        success: true,
-                        data: { action: 'set', key, value }
-                    };
-                }
-                // Handle config reset
-                if (args[0] === 'reset') {
-                    return {
-                        success: true,
-                        data: { action: 'reset' }
-                    };
-                }
-                return {
-                    success: false,
-                    message: 'Usage: /config [set <key> <value> | reset]'
-                };
+class CommandParser {
+  commands = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerDefaultCommands();
+  }
+  registerDefaultCommands() {
+    this.register({
+      name: "help",
+      description: "Show available commands",
+      aliases: ["h", "?"],
+      execute: async () => ({
+        success: true,
+        action: "show-help",
+        data: this.getHelp()
+      })
+    });
+    this.register({
+      name: "model",
+      description: "Select AI model",
+      aliases: ["m"],
+      execute: async (args) => {
+        if (args.length > 0) {
+          return {
+            success: true,
+            data: { model: args.join(" ") }
+          };
+        }
+        return {
+          success: true,
+          action: "show-model-picker"
+        };
+      }
+    });
+    this.register({
+      name: "config",
+      description: "View or edit configuration",
+      aliases: ["c", "settings"],
+      execute: async (args) => {
+        if (args.length === 0) {
+          return {
+            success: true,
+            action: "show-config"
+          };
+        }
+        if (args[0] === "set" && args.length >= 3) {
+          const key = args[1];
+          const value = args.slice(2).join(" ");
+          return {
+            success: true,
+            data: { action: "set", key, value }
+          };
+        }
+        if (args[0] === "reset") {
+          return {
+            success: true,
+            data: { action: "reset" }
+          };
+        }
+        return {
+          success: false,
+          message: "Usage: /config [set <key> <value> | reset]"
+        };
+      }
+    });
+    this.register({
+      name: "clear",
+      description: "Clear conversation history",
+      aliases: ["cls", "reset"],
+      execute: async () => ({
+        success: true,
+        action: "clear"
+      })
+    });
+    this.register({
+      name: "exit",
+      description: "Exit Centaurus CLI",
+      aliases: ["quit", "q"],
+      execute: async () => ({
+        success: true,
+        action: "exit"
+      })
+    });
+    this.register({
+      name: "session",
+      description: "Manage sessions",
+      aliases: ["s"],
+      execute: async (args) => {
+        if (args.length === 0) {
+          return {
+            success: true,
+            message: "Usage: /session [save|load|list|export]"
+          };
+        }
+        const subcommand = args[0];
+        switch (subcommand) {
+          case "save":
+            return {
+              success: true,
+              data: { action: "save", name: args[1] || `session-${Date.now()}` }
+            };
+          case "load":
+            if (args.length < 2) {
+              return {
+                success: false,
+                message: "Please specify session name to load"
+              };
             }
-        });
-        this.register({
-            name: 'clear',
-            description: 'Clear conversation history',
-            aliases: ['cls', 'reset'],
-            execute: async () => ({
+            return {
+              success: true,
+              data: { action: "load", name: args[1] }
+            };
+          case "list":
+            return {
+              success: true,
+              data: { action: "list" }
+            };
+          case "export":
+            return {
+              success: true,
+              data: { action: "export", format: args[1] || "markdown" }
+            };
+          default:
+            return {
+              success: false,
+              message: `Unknown session command: ${subcommand}`
+            };
+        }
+      }
+    });
+    this.register({
+      name: "tools",
+      description: "List available tools",
+      aliases: ["t"],
+      execute: async () => ({
+        success: true,
+        data: { action: "list-tools" }
+      })
+    });
+    this.register({
+      name: "plan",
+      description: "Toggle plan mode for complex implementations",
+      execute: async () => ({
+        success: true,
+        action: "toggle-plan-mode"
+      })
+    });
+    this.register({
+      name: "workflow",
+      description: "Manage workflows (new, list, run, delete, view)",
+      aliases: ["wf"],
+      execute: async (args) => {
+        if (args.length === 0) {
+          return {
+            success: true,
+            message: `\u{1F4CB} **Workflow Commands:**
+
+  **/workflow new** - Create a new workflow
+  **/workflow list** - List saved workflows
+  **/workflow run <name>** - Run a workflow
+  **/workflow view <name>** - View workflow steps
+  **/workflow delete <name>** - Delete a workflow
+
+**What are workflows?**
+Workflows let you save and replay sequences of commands and instructions.
+Create once, run many times across different machines.`
+          };
+        }
+        const subcommand = args[0].toLowerCase();
+        const workflowName = args.slice(1).join(" ");
+        switch (subcommand) {
+          case "new":
+          case "create":
+            const newSubcommand = args[1]?.toLowerCase();
+            if (newSubcommand === "manual") {
+              return {
                 success: true,
-                action: 'clear'
-            })
-        });
-        this.register({
-            name: 'exit',
-            description: 'Exit Centaurus CLI',
-            aliases: ['quit', 'q'],
-            execute: async () => ({
+                action: "show-workflow-creator"
+              };
+            } else if (newSubcommand === "learn-workflow") {
+              return {
                 success: true,
-                action: 'exit'
-            })
-        });
-        this.register({
-            name: 'session',
-            description: 'Manage sessions',
-            aliases: ['s'],
-            execute: async (args) => {
-                if (args.length === 0) {
-                    return {
-                        success: true,
-                        message: 'Usage: /session [save|load|list|export]'
-                    };
-                }
-                const subcommand = args[0];
-                switch (subcommand) {
-                    case 'save':
-                        return {
-                            success: true,
-                            data: { action: 'save', name: args[1] || `session-${Date.now()}` }
-                        };
-                    case 'load':
-                        if (args.length < 2) {
-                            return {
-                                success: false,
-                                message: 'Please specify session name to load'
-                            };
-                        }
-                        return {
-                            success: true,
-                            data: { action: 'load', name: args[1] }
-                        };
-                    case 'list':
-                        return {
-                            success: true,
-                            data: { action: 'list' }
-                        };
-                    case 'export':
-                        return {
-                            success: true,
-                            data: { action: 'export', format: args[1] || 'markdown' }
-                        };
-                    default:
-                        return {
-                            success: false,
-                            message: `Unknown session command: ${subcommand}`
-                        };
-                }
+                action: "toggle-workflow-learning"
+              };
+            } else if (newSubcommand) {
+              return {
+                success: false,
+                message: `Unknown workflow new subcommand: ${newSubcommand}. Use 'manual' or 'learn-workflow'.`
+              };
             }
-        });
-        this.register({
-            name: 'tools',
-            description: 'List available tools',
-            aliases: ['t'],
-            execute: async () => ({
-                success: true,
-                data: { action: 'list-tools' }
-            })
-        });
-        this.register({
-            name: 'plan',
-            description: 'Toggle plan mode for complex implementations',
-            execute: async () => ({
-                success: true,
-                action: 'toggle-plan-mode'
-            })
-        });
-        this.register({
-            name: 'workflow',
-            description: 'Manage workflows (new, list, run, delete, view)',
-            aliases: ['wf'],
-            execute: async (args) => {
-                if (args.length === 0) {
-                    return {
-                        success: true,
-                        message: `📋 **Workflow Commands:**
-
-  **/workflow new** - Create a new workflow
-  **/workflow list** - List saved workflows
-  **/workflow run <name>** - Run a workflow
-  **/workflow view <name>** - View workflow steps
-  **/workflow delete <name>** - Delete a workflow
-
-**What are workflows?**
-Workflows let you save and replay sequences of commands and instructions.
-Create once, run many times across different machines.`
-                    };
-                }
-                const subcommand = args[0].toLowerCase();
-                const workflowName = args.slice(1).join(' ');
-                switch (subcommand) {
-                    case 'new':
-                    case 'create':
-                        // Check for nested subcommand (manual or learn-workflow)
-                        const newSubcommand = args[1]?.toLowerCase();
-                        if (newSubcommand === 'manual') {
-                            return {
-                                success: true,
-                                action: 'show-workflow-creator'
-                            };
-                        }
-                        else if (newSubcommand === 'learn-workflow') {
-                            return {
-                                success: true,
-                                action: 'toggle-workflow-learning'
-                            };
-                        }
-                        else if (newSubcommand) {
-                            // Unknown subcommand
-                            return {
-                                success: false,
-                                message: `Unknown workflow new subcommand: ${newSubcommand}. Use 'manual' or 'learn-workflow'.`
-                            };
-                        }
-                        // No subcommand - show help for new options
-                        return {
-                            success: true,
-                            message: `📋 **Create a New Workflow:**
-
-  **/workflow new manual** - Manually create by typing steps
-  **/workflow new learn-workflow** - Learn from your commands and prompts
-
-**Manual Mode:** Type each step one at a time, toggle between command/instruction mode.
-
+            return {
+              success: true,
+              message: `\u{1F4CB} **Create a New Workflow:**
+
+  **/workflow new manual** - Manually create by typing steps
+  **/workflow new learn-workflow** - Learn from your commands and prompts
+
+**Manual Mode:** Type each step one at a time, toggle between command/instruction mode.
+
 **Learn Mode:** Start learning, then run commands and prompts naturally. Run the command again to save.`
-                        };
-                    case 'list':
-                    case 'ls':
-                        return {
-                            success: true,
-                            action: 'show-workflow-list'
-                        };
-                    case 'run':
-                    case 'execute':
-                        if (!workflowName) {
-                            return {
-                                success: false,
-                                message: 'Usage: /workflow run <name>'
-                            };
-                        }
-                        return {
-                            success: true,
-                            action: 'run-workflow',
-                            data: { name: workflowName }
-                        };
-                    case 'view':
-                    case 'show':
-                        if (!workflowName) {
-                            return {
-                                success: false,
-                                message: 'Usage: /workflow view <name>'
-                            };
-                        }
-                        return {
-                            success: true,
-                            action: 'view-workflow',
-                            data: { name: workflowName }
-                        };
-                    case 'delete':
-                    case 'rm':
-                    case 'remove':
-                        if (!workflowName) {
-                            return {
-                                success: false,
-                                message: 'Usage: /workflow delete <name>'
-                            };
-                        }
-                        return {
-                            success: true,
-                            action: 'delete-workflow',
-                            data: { name: workflowName }
-                        };
-                    default:
-                        return {
-                            success: false,
-                            message: `Unknown workflow command: ${subcommand}. Use /workflow for help.`
-                        };
-                }
+            };
+          case "list":
+          case "ls":
+            return {
+              success: true,
+              action: "show-workflow-list"
+            };
+          case "run":
+          case "execute":
+            if (!workflowName) {
+              return {
+                success: false,
+                message: "Usage: /workflow run <name>"
+              };
             }
-        });
-    }
-    register(command) {
-        this.commands.set(command.name, command);
-        // Also register aliases
-        if (command.aliases) {
-            for (const alias of command.aliases) {
-                this.commands.set(alias, command);
+            return {
+              success: true,
+              action: "run-workflow",
+              data: { name: workflowName }
+            };
+          case "view":
+          case "show":
+            if (!workflowName) {
+              return {
+                success: false,
+                message: "Usage: /workflow view <name>"
+              };
             }
-        }
-    }
-    async parse(input) {
-        if (!input.startsWith('/')) {
-            return null;
-        }
-        const parts = input.slice(1).trim().split(/\s+/);
-        if (parts.length === 0 || parts[0] === '') {
-            return null;
-        }
-        const commandName = parts[0].toLowerCase();
-        const args = parts.slice(1);
-        const command = this.commands.get(commandName);
-        if (!command) {
             return {
+              success: true,
+              action: "view-workflow",
+              data: { name: workflowName }
+            };
+          case "delete":
+          case "rm":
+          case "remove":
+            if (!workflowName) {
+              return {
                 success: false,
-                message: `Unknown command: ${commandName}. Type /help for available commands.`
+                message: "Usage: /workflow delete <name>"
+              };
+            }
+            return {
+              success: true,
+              action: "delete-workflow",
+              data: { name: workflowName }
+            };
+          default:
+            return {
+              success: false,
+              message: `Unknown workflow command: ${subcommand}. Use /workflow for help.`
             };
         }
-        try {
-            return await command.execute(args);
+      }
+    });
+    this.register({
+      name: "rules",
+      description: "Manage reusable prompt rules (list, add, edit, delete)",
+      execute: async (args) => {
+        if (args.length === 0) {
+          return {
+            success: true,
+            message: `\u{1F4DC} **Rule Commands:**
+
+  **/rules list** - List saved rules
+  **/rules add** - Create a new reusable rule
+  **/rules edit <name>** - Edit an existing rule
+  **/rules delete <name>** - Delete a saved rule
+
+**How to use rules**
+Reference a saved rule inside any prompt with \`@rules:<name>\`.`
+          };
         }
-        catch (error) {
+        const subcommand = args[0].toLowerCase();
+        const ruleName = args.slice(1).join(" ");
+        switch (subcommand) {
+          case "list":
+          case "ls":
+            return {
+              success: true,
+              action: "list-rules"
+            };
+          case "add":
+          case "new":
+          case "create":
             return {
+              success: true,
+              action: "show-rules-editor",
+              data: { mode: "add" }
+            };
+          case "edit":
+            if (!ruleName) {
+              return {
                 success: false,
-                message: `Error executing command: ${error.message}`
+                message: "Usage: /rules edit <name>"
+              };
+            }
+            return {
+              success: true,
+              action: "show-rules-editor",
+              data: { mode: "edit", name: ruleName }
             };
-        }
-    }
-    getHelp() {
-        const uniqueCommands = new Map();
-        // Get unique commands (skip aliases)
-        for (const [name, command] of this.commands) {
-            if (name === command.name) {
-                uniqueCommands.set(name, command);
+          case "delete":
+          case "rm":
+          case "remove":
+            if (!ruleName) {
+              return {
+                success: false,
+                message: "Usage: /rules delete <name>"
+              };
             }
+            return {
+              success: true,
+              action: "delete-rule",
+              data: { name: ruleName }
+            };
+          default:
+            return {
+              success: false,
+              message: `Unknown rules command: ${subcommand}. Use /rules for help.`
+            };
         }
-        let help = '📚 **Available Commands:**\n\n';
-        for (const command of uniqueCommands.values()) {
-            const aliases = command.aliases ? ` (${command.aliases.join(', ')})` : '';
-            help += `  **/${command.name}${aliases}** - ${command.description}\n`;
-        }
-        help += '\n⌨️ **Keyboard Shortcuts:**\n';
-        help += '  **Ctrl+T** - Toggle auto-accept mode\n';
-        help += '  **Ctrl+C** - Exit application\n';
-        help += '  **?** - Show this help\n';
-        help += '\n💡 **Examples:**\n';
-        help += '  `/model gemini-2.5-flash` - Switch to a specific model\n';
-        help += '  `/config set model gemini-2.5-pro` - Set preferred model\n';
-        help += '  `/session save my-work` - Save current session\n';
-        help += '\n📝 **Note:**\n';
-        help += '  All AI requests are handled through the backend using Google Gemini models.\n';
-        return help;
+      }
+    });
+  }
+  register(command) {
+    this.commands.set(command.name, command);
+    if (command.aliases) {
+      for (const alias of command.aliases) {
+        this.commands.set(alias, command);
+      }
+    }
+  }
+  async parse(input) {
+    if (!input.startsWith("/")) {
+      return null;
+    }
+    const parts = input.slice(1).trim().split(/\s+/);
+    if (parts.length === 0 || parts[0] === "") {
+      return null;
+    }
+    const commandName = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const command = this.commands.get(commandName);
+    if (!command) {
+      return {
+        success: false,
+        message: `Unknown command: ${commandName}. Type /help for available commands.`
+      };
+    }
+    try {
+      return await command.execute(args);
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error executing command: ${error.message}`
+      };
+    }
+  }
+  getHelp() {
+    const uniqueCommands = /* @__PURE__ */ new Map();
+    for (const [name, command] of this.commands) {
+      if (name === command.name) {
+        uniqueCommands.set(name, command);
+      }
     }
-    isCommand(input) {
-        return input.startsWith('/');
+    let help = "\u{1F4DA} **Available Commands:**\n\n";
+    for (const command of uniqueCommands.values()) {
+      const aliases = command.aliases ? ` (${command.aliases.join(", ")})` : "";
+      help += `  **/${command.name}${aliases}** - ${command.description}
+`;
     }
+    help += "\n\u2328\uFE0F **Keyboard Shortcuts:**\n";
+    help += "  **Ctrl+T** - Toggle auto-accept mode\n";
+    help += "  **Ctrl+C** - Exit application\n";
+    help += "  **?** - Show this help\n";
+    help += "\n\u{1F4A1} **Examples:**\n";
+    help += "  `/model gemini-2.5-flash` - Switch to a specific model\n";
+    help += "  `/config set model gemini-2.5-pro` - Set preferred model\n";
+    help += "  `/session save my-work` - Save current session\n";
+    help += "\n\u{1F4DD} **Note:**\n";
+    help += "  All AI requests are handled through the backend using Google Gemini models.\n";
+    return help;
+  }
+  isCommand(input) {
+    return input.startsWith("/");
+  }
 }
-export default CommandParser;
+var CommandParser_default = CommandParser;
+export {
+  CommandParser,
+  CommandParser_default as default
+};
 //# sourceMappingURL=CommandParser.js.map