@nevermorelove/ompp 0.3.2 → 0.4.1

package/README.md

@@ -32,6 +32,10 @@ ompp list               print mode names
 ompp pentest --dry-run  show the omp command line instead of running it
 ```
 
+In the picker, `r` renames the highlighted mode and `d` deletes it (after a
+confirmation). The picker reopens after either, so a mispress costs nothing:
+cancel the rename or keep the mode, and you are back in the list.
+
 Before launch it prints one line to stderr, `[ompp] mode: pentest`, so you always know where you are.
 
 Modes are read from two places, and same-named modes from the first win:

package/ompp.js

@@ -226,6 +226,7 @@ function usage() {
 
 Usage:
   ompp                    pick a mode interactively, then launch omp
+                          (r: rename, d: delete on the highlighted mode)
   ompp <mode> [args...]   launch omp in a mode; everything after <mode>
                           is passed to omp unchanged and wins over the mode
   ompp create <name>      create a new mode with placeholder files
@@ -343,44 +344,129 @@ function createMode(name) {
   return 0;
 }
 
+function renameMode(mode, newName) {
+  if (!newName || !isValidModeName(newName)) {
+    console.error(`[ompp] "${newName}" is not a valid mode name.`);
+    return false;
+  }
+  if (RESERVED_NAMES.includes(newName)) {
+    console.error(`[ompp] "${newName}" is reserved for ompp commands.`);
+    return false;
+  }
+  const from = modeDirOf(mode.name, mode.source);
+  const to = modeDirOf(newName, mode.source);
+  if (fs.existsSync(to)) {
+    console.error(`[ompp] mode "${newName}" already exists.`);
+    return false;
+  }
+  fs.renameSync(from, to);
+  console.error(`[ompp] renamed "${mode.name}" to "${newName}"`);
+  return true;
+}
+
+function deleteMode(mode) {
+  const dir = modeDirOf(mode.name, mode.source);
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.error(`[ompp] deleted mode "${mode.name}"`);
+  return true;
+}
+
 const CREATE_OPTION = "__create__";
 
 function isValidModeName(name) {
   return /^[a-z0-9][a-z0-9-]*$/.test(name);
 }
 
-async function pickMode(modeNames) {
-  const { select, text, isCancel, cancel } = require("@clack/prompts");
-  const options = [
-    ...modeNames.map((name) => ({ value: name, label: name })),
-    { value: CREATE_OPTION, label: "Create a new mode +" },
-  ];
-  const chosen = await select({
-    message: "Pick a mode",
-    options,
-  });
-  if (isCancel(chosen)) {
-    cancel("Cancelled");
-    process.exit(130);
-  }
-  if (chosen === CREATE_OPTION) {
-    const name = await text({
-      message: "New mode name",
-      validate: (v) => {
-        if (!v || !isValidModeName(v)) {
-          return "Lowercase letters, digits, and dashes only";
-        }
-        if (RESERVED_NAMES.includes(v)) return `"${v}" is reserved`;
-        return undefined;
-      },
+// The interactive picker. Receives mode objects ({name, source}), returns
+// the picked mode object, or {create: <name>} for the create flow.
+// r renames and d deletes the highlighted mode; both re-render the picker.
+async function pickMode(modes) {
+  const { select, text, confirm, isCancel, cancel } = require("@clack/prompts");
+  for (;;) {
+    const options = [
+      ...modes.map((m) => ({ value: m, label: m.name })),
+      { value: CREATE_OPTION, label: "Create a new mode +" },
+    ];
+    const chosen = await select({
+      message: "Pick a mode",
+      options,
     });
-    if (isCancel(name)) {
+
+    if (isCancel(chosen)) {
       cancel("Cancelled");
       process.exit(130);
     }
-    return { create: name };
+
+    if (chosen === CREATE_OPTION) {
+      const name = await text({
+        message: "New mode name",
+        validate: (v) => {
+          if (!v || !isValidModeName(v)) {
+            return "Lowercase letters, digits, and dashes only";
+          }
+          if (RESERVED_NAMES.includes(v)) return `"${v}" is reserved`;
+          return undefined;
+        },
+      });
+      if (isCancel(name)) {
+        cancel("Cancelled");
+        process.exit(130);
+      }
+      return { create: name };
+    }
+
+    // Second step: what to do with the picked mode. This replaces the
+    // previous r/d hotkey hack (process.stdin keypress rewrite) which left
+    // Windows terminals in raw mode and hung randomly.
+    const action = await select({
+      message: `Mode "${chosen.name}" — what next?`,
+      options: [
+        { value: "launch", label: "Launch" },
+        { value: "rename", label: "Rename" },
+        { value: "delete", label: "Delete" },
+        { value: "back", label: "Back" },
+      ],
+    });
+
+    if (isCancel(action) || action === "back") continue;
+    if (action === "launch") return chosen;
+
+    if (action === "rename") {
+      const newName = await text({
+        message: `Rename "${chosen.name}" to`,
+        validate: (v) => {
+          if (!v || !isValidModeName(v)) {
+            return "Lowercase letters, digits, and dashes only";
+          }
+          if (RESERVED_NAMES.includes(v)) return `"${v}" is reserved`;
+          if (modes.some((m) => m.name === v)) return `"${v}" already exists`;
+          return undefined;
+        },
+      });
+      if (!isCancel(newName) && newName !== chosen.name) {
+        if (renameMode(chosen, newName)) chosen.name = newName;
+      } else {
+        cancel("Rename cancelled");
+      }
+      continue;
+    }
+
+    if (action === "delete") {
+      const sure = await confirm({
+        message: `Delete "${chosen.name}"? This removes its folder.`,
+        active: "Delete",
+        inactive: "Keep",
+      });
+      if (!isCancel(sure) && sure) {
+        deleteMode(chosen);
+        const idx = modes.findIndex((m) => m.name === chosen.name);
+        if (idx !== -1) modes.splice(idx, 1);
+      } else {
+        cancel("Delete cancelled");
+      }
+      continue;
+    }
   }
-  return chosen;
 }
 
 // Non-TTY stdin: clack needs an interactive terminal, so numbered input.
@@ -521,16 +607,20 @@ async function main() {
 
   if (!mode) {
     try {
-      const picked = process.stdin.isTTY
-        ? await pickMode(modeNames)
+      let picked = process.stdin.isTTY
+        ? await pickMode(modes)
         : await pickModePiped(modeNames);
+      if (typeof picked === "string") {
+        // The piped picker returns a name; normalize to the mode object.
+        picked = modes.find((m) => m.name === picked);
+      }
       if (picked && typeof picked === "object" && picked.create) {
         // Scaffold and stop: the mode is all placeholders, launching it
         // now would run an unconfigured mode. The user fills it in and
         // launches when ready.
         return createMode(picked.create);
       } else {
-        mode = modes.find((m) => m.name === picked);
+        mode = picked;
       }
     } catch (err) {
       console.error(`[ompp] ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nevermorelove/ompp",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "Mode presets for the omp coding agent: one folder per mode, zero config code.",
   "repository": {
     "type": "git",