@nevermorelove/ompp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ForeverInLaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# ompp
+
+Mode presets for the [omp](https://github.com/can1357/oh-my-pi) coding agent.
+
+omp loads every skill, prompt file, and MCP server it can find on your machine, every session. With 80 skills installed, the system prompt carries 80 descriptions even when three would do, and switching personas means renaming `SYSTEM.md` by hand.
+
+ompp gives each kind of work a name and a folder. Launch a session in a mode and it starts with only what that work needs.
+
+## Install
+
+```sh
+git clone git@github.com:ForeverInLaw/ompp.git
+cd ompp
+npm install -g .
+```
+
+Node 18 or newer, that is the whole requirement. bun works too. After install, `ompp` is on your PATH. To update, `git pull` and install again.
+
+## Usage
+
+```sh
+ompp                    arrow-key picker, then launches omp
+ompp pentest            launch in a mode
+ompp writing -p "..."   mode plus any omp flags
+ompp list               print mode names
+ompp pentest --dry-run  show the omp command line instead of running it
+```
+
+Before launch it prints one line to stderr, `[ompp] mode: pentest`, so you always know where you are.
+
+## What a mode is
+
+A folder under `modes/`. Every file is optional, whatever exists gets wired into the launch flags.
+
+```
+modes/pentest/
+  config.yml      settings overlay
+  system.md       full system prompt replacement
+  append.md       prompt addendum, used when system.md is absent
+  skills/         skills only this mode sees
+  .mcp.json       MCP servers only this mode gets
+  prompts/ commands/ rules/ hooks/ tools/   also load from the mode folder
+```
+
+| File | omp flag | What goes in it |
+| --- | --- | --- |
+| `config.yml` | `--config` | Any OMP setting. `modelRoles.default`, `defaultThinkingLevel`, `tools.approvalMode`, the `skills.includeSkills` glob allowlist and friends. |
+| `system.md` | `--system-prompt` | Replaces the prompt whole. The default omp instructions, your global `SYSTEM.md`, and the built-in tool policy are gone. Write what you need. |
+| `append.md` | `--append-system-prompt` | Rides on top of your normal prompt. This is what most modes want. |
+| the folder itself | `--plugin-dir` | omp treats the mode folder as a plugin root, so `skills/` and `.mcp.json` inside it load too. |
+
+A new mode is `mkdir modes/<name>` plus files. No manifest, no code. The wrapper reads the folder, so it never needs to change when you add modes. `modes/general` is a working example to copy from.
+
+## Precedence
+
+Your flags beat the mode.
+
+`ompp pentest --model anthropic/claude-sonnet-4-5` runs Sonnet even when the mode's `config.yml` says otherwise. An explicit `--system-prompt` on the command line disables the mode's prompt file for that run. Later `--config` overlays win too, so single keys can be overridden ad hoc.
+
+`append.md` stacks on omp's default prompt plus your global `~/.omp/agent/SYSTEM.md` if you have one. A mode with `system.md` replaces all of it.
+
+## Limits worth knowing
+
+MCP servers can be added by a mode but never removed. omp has no launch-time MCP filter, so a mode that wants fewer servers than your global `mcp.json` provides has to live with them. This is the one gap that would need an omp extension to close.
+
+Mode-local `skills/` are additive as well. To have fewer skills, set `skills.includeSkills` in the mode's `config.yml`. The allowlist filters every discovered skill, global ones included.
+
+The picker needs a TTY. Piped or otherwise headless stdin gets a numbered prompt instead.
+
+## Environment
+
+- `OMPP_MODES_DIR`, where modes live. Default is `modes/` next to the script.
+- `OMPP_OMP_BIN`, which omp to launch. Default is omp from PATH.

package/modes/general/append.md

@@ -0,0 +1,3 @@
+# General
+
+Answer directly and briefly. No preamble, no restating the question.

package/modes/general/config.yml

@@ -0,0 +1,8 @@
+modelRoles:
+  default: crusoe/zai-org/GLM-5.3:max
+defaultThinkingLevel: high
+skills:
+  includeSkills:
+    - unslop
+    - tdd
+    - diagnosing-bugs

package/ompp.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+/**
+ * ompp — mode presets for the omp coding agent.
+ *
+ * A mode is a folder under modes/. Whatever the folder contains gets wired
+ * into the omp launch flags:
+ *
+ *   config.yml | config.yaml  -> --config               (settings overlay)
+ *   system.md                 -> --system-prompt         (replaces default prompt)
+ *   append.md                 -> --append-system-prompt  (used when system.md is absent)
+ *   skills/ .mcp.json prompts/ commands/ rules/ hooks/ tools/
+ *                            -> --plugin-dir             (mode-local skills and MCP)
+ *
+ * Every file is optional. Everything after the mode name goes to omp as-is;
+ * user flags win over the mode.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const MODES_DIR = process.env.OMPP_MODES_DIR || path.join(__dirname, "modes");
+const CONFIG_NAMES = ["config.yml", "config.yaml"];
+const PLUGIN_ARTIFACTS = [
+  "skills",
+  ".mcp.json",
+  "prompts",
+  "commands",
+  "rules",
+  "hooks",
+  "tools",
+];
+
+function firstExisting(dir, names) {
+  for (const n of names) {
+    const p = path.join(dir, n);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function discoverModes() {
+  const modes = [];
+  const skipped = [];
+  if (!fs.existsSync(MODES_DIR)) return { modes, skipped };
+  const entries = fs
+    .readdirSync(MODES_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+  for (const name of entries) {
+    if (name.startsWith(".") || name.startsWith("_")) continue;
+    const dir = path.join(MODES_DIR, name);
+    const hasSomething = firstExisting(dir, [
+      ...CONFIG_NAMES,
+      "system.md",
+      "append.md",
+      ...PLUGIN_ARTIFACTS,
+    ]);
+    if (hasSomething) modes.push(name);
+    else skipped.push(name);
+  }
+  return { modes, skipped };
+}
+
+function buildArgv(modeDir, userArgs) {
+  const args = [];
+  // An explicit user flag replaces the mode's counterpart instead of racing it.
+  const userHas = (flag) =>
+    userArgs.some((a) => a === flag || a.startsWith(flag + "="));
+
+  const cfg = firstExisting(modeDir, CONFIG_NAMES);
+  if (cfg) args.push("--config", cfg);
+
+  const systemMd = path.join(modeDir, "system.md");
+  const appendMd = path.join(modeDir, "append.md");
+  if (fs.existsSync(systemMd) && !userHas("--system-prompt")) {
+    args.push("--system-prompt", systemMd);
+  } else if (fs.existsSync(appendMd) && !userHas("--append-system-prompt")) {
+    args.push("--append-system-prompt", appendMd);
+  }
+
+  if (firstExisting(modeDir, PLUGIN_ARTIFACTS)) {
+    args.push("--plugin-dir", modeDir);
+  }
+
+  args.push(...userArgs);
+  return args;
+}
+
+function resolveBin() {
+  const override = process.env.OMPP_OMP_BIN;
+  if (override) {
+    const needsShell =
+      process.platform === "win32" && /\.(cmd|bat)$/i.test(override);
+    return { bin: override, shell: needsShell };
+  }
+  if (process.platform !== "win32") return { bin: "omp", shell: false };
+  // Windows: Node's spawn does no PATHEXT resolution, find omp ourselves.
+  const exts = (process.env.PATHEXT || ".exe;.cmd;.bat")
+    .split(";")
+    .filter(Boolean);
+  const pathDirs = (process.env.PATH || "").split(path.delimiter);
+  for (const dir of pathDirs) {
+    const d = dir.replace(/^"|"$/g, "");
+    if (!d) continue;
+    for (const ext of exts) {
+      const cand = path.join(d, "omp" + ext.toLowerCase());
+      if (!fs.existsSync(cand)) continue;
+      return {
+        bin: cand,
+        shell: /\.(cmd|bat)$/i.test(cand),
+      };
+    }
+  }
+  return { bin: "omp", shell: true }; // last resort: let the shell find it
+}
+
+function winQuote(s) {
+  if (!/[\s"]/ .test(s)) return s;
+  return '"' + s.replace(/"/g, '""') + '"';
+}
+
+
+function usage() {
+  console.log(`ompp — mode presets for the omp coding agent
+
+Usage:
+  ompp                    pick a mode interactively, then launch omp
+  ompp <mode> [args...]   launch omp in a mode; everything after <mode>
+                          is passed to omp unchanged and wins over the mode
+  ompp list               list available modes
+
+A mode is a folder under modes/. All files are optional:
+  config.yml              settings overlay: model, thinking level,
+                         skills.includeSkills allowlist, approval mode, ...
+  system.md               replaces the system prompt entirely
+  append.md               appended to the system prompt (unless system.md exists)
+  skills/                 mode-local skills (SKILL.md needs a description)
+  .mcp.json               mode-local MCP servers, added on top of global ones
+  prompts/ commands/ rules/ hooks/ tools/   also load from the mode folder
+
+Flags:
+  --dry-run               print the omp command line instead of launching
+  -h, --help              this help
+  -v, --version           version
+
+Environment:
+  OMPP_MODES_DIR          modes directory (default: modes/ next to this script)
+  OMPP_OMP_BIN            omp executable to launch (default: omp from PATH)`);
+}
+
+function pickInteractive(modes) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let idx = 0;
+    let settled = false;
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      process.stdout.write("\u001b[?25h"); // show cursor
+      if (value === null) reject(new Error("mode selection cancelled"));
+      else resolve(value);
+    };
+
+    const render = (first) => {
+      if (!first) process.stdout.write(`\u001b[${modes.length}A`);
+      const body = modes
+        .map((m, i) => (i === idx ? "> " + m : "  " + m))
+        .map((l) => "\u001b[2K" + l)
+        .join("\n");
+      process.stdout.write("\u001b[?25l" + body + "\n");
+    };
+
+    function onData(buf) {
+      // A single read can carry several keys (arrow + Enter glued together,
+      // a paste). Walk key by key instead of matching the whole chunk.
+      const s = buf.toString();
+      let i = 0;
+      while (i < s.length) {
+        const ch = s[i];
+        if (ch === "\u001b") {
+          const seq = s.slice(i);
+          if (seq.startsWith("\u001b[A") || seq.startsWith("\u001b[B") ||
+              seq.startsWith("\u001b[C") || seq.startsWith("\u001b[D")) {
+            if (seq.startsWith("\u001b[A")) {
+              idx = (idx - 1 + modes.length) % modes.length;
+              render(false);
+            } else if (seq.startsWith("\u001b[B")) {
+              idx = (idx + 1) % modes.length;
+              render(false);
+            } // C/D: left/right, ignore
+            i += 3;
+            continue;
+          }
+          if (seq.length === 1) {
+            // Bare escape with nothing after it in this chunk: cancel.
+            finish(null);
+            process.exit(0);
+          }
+          i++; // unknown or split sequence, skip the escape byte
+          continue;
+        }
+        if (ch === "\r" || ch === "\n") return finish(modes[idx]);
+        if (ch === "\u0003") {
+          // Ctrl+C: restore the terminal and bail like a shell would.
+          finish(null);
+          process.exit(130);
+        }
+        if (ch === "q") {
+          finish(null);
+          process.exit(0);
+        }
+        if (ch === "j") {
+          idx = (idx + 1) % modes.length;
+          render(false);
+        }
+        if (ch === "k") {
+          idx = (idx - 1 + modes.length) % modes.length;
+          render(false);
+        }
+        i++;
+      }
+    }
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+    render(true);
+  });
+}
+
+function pickByNumber(modes) {
+  return new Promise((resolve, reject) => {
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin });
+    process.stdout.write("Select a mode:\n");
+    modes.forEach((m, i) => process.stdout.write(`  ${i + 1}. ${m}\n`));
+    process.stdout.write(`Choice [1-${modes.length}]: `);
+    rl.once("line", (line) => {
+      rl.close();
+      const n = parseInt(line.trim(), 10);
+      if (n >= 1 && n <= modes.length) resolve(modes[n - 1]);
+      else reject(new Error(`"${line.trim()}" is not a valid choice`));
+    });
+    rl.once("close", () => {
+      reject(new Error("no mode selected"));
+    });
+  });
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+
+  if (argv[0] === "list") {
+    const { modes, skipped } = discoverModes();
+    if (!modes.length) {
+      console.error(
+        `[ompp] no modes found in ${MODES_DIR}. Create modes/<name>/ with at least one mode file.`,
+      );
+      return 1;
+    }
+    for (const m of modes) console.log(m);
+    if (skipped.length) {
+      console.error(
+        `[ompp] skipped folders without recognized files: ${skipped.join(", ")}`,
+      );
+    }
+    return 0;
+  }
+
+  if (["-h", "--help", "help"].includes(argv[0])) {
+    usage();
+    return 0;
+  }
+  if (["-v", "--version", "version"].includes(argv[0])) {
+    console.log(require("./package.json").version);
+    return 0;
+  }
+
+  const dryRun = argv.includes("--dry-run");
+  const rest = argv.filter((a) => a !== "--dry-run");
+
+  const { modes, skipped } = discoverModes();
+  if (skipped.length) {
+    console.error(
+      `[ompp] skipped folders without recognized files: ${skipped.join(", ")}`,
+    );
+  }
+  if (!modes.length) {
+    console.error(
+      `[ompp] no modes found in ${MODES_DIR}. Create modes/<name>/ with at least one mode file.`,
+    );
+    return 1;
+  }
+
+  let mode = null;
+  let userArgs = rest;
+  if (rest.length && !rest[0].startsWith("-")) {
+    const candidate = rest[0];
+    if (modes.includes(candidate)) {
+      mode = candidate;
+      userArgs = rest.slice(1);
+    } else {
+      console.error(`[ompp] unknown mode "${candidate}"`);
+      console.error(`[ompp] available: ${modes.join(", ")}`);
+      return 1;
+    }
+  } else {
+    try {
+      mode = process.stdin.isTTY
+        ? await pickInteractive(modes)
+        : await pickByNumber(modes);
+    } catch (err) {
+      console.error(`[ompp] ${err.message}`);
+      return 1;
+    }
+  }
+
+  const modeDir = path.join(MODES_DIR, mode);
+  const args = buildArgv(modeDir, userArgs);
+  const { bin, shell } = resolveBin();
+
+  if (dryRun) {
+    console.error(`[ompp] mode: ${mode}`);
+    console.error(`[ompp] omp: ${bin}${shell ? " (shell)" : ""}`);
+    console.error(`[ompp] argv: ${JSON.stringify(args)}`);
+    return 0;
+  }
+
+  console.error(`[ompp] mode: ${mode}`);
+  const child = shell
+    ? spawn([winQuote(bin), ...args.map(winQuote)].join(" "), {
+        stdio: "inherit",
+        shell: true,
+      })
+    : spawn(bin, args, { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(`[ompp] failed to start omp: ${err.message}`);
+    process.exitCode = 1;
+  });
+  child.on("exit", (code, signal) => {
+    process.exitCode = code ?? (signal ? 1 : 0);
+  });
+  return 0;
+}
+
+main()
+  .then((code) => {
+    if (code) process.exitCode = code;
+  })
+  .catch((err) => {
+    console.error(`[ompp] ${err.stack || err.message}`);
+    process.exitCode = 1;
+  });

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@nevermorelove/ompp",
+  "version": "0.1.0",
+  "description": "Mode presets for the omp coding agent: one folder per mode, zero config code.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForeverInLaw/ompp.git"
+  },
+  "bin": {
+    "ompp": "ompp.js"
+  },
+  "files": [
+    "ompp.js",
+    "modes/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "omp",
+    "oh-my-pi",
+    "coding-agent",
+    "presets",
+    "cli"
+  ],
+  "author": "ForeverInLaw",
+  "license": "MIT"
+}