@meshxdata/fops 0.0.4 → 0.0.6

package/src/plugins/bundled/cursor/index.js

@@ -0,0 +1,432 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+
+/**
+ * Resolve the cursor CLI binary path.
+ * Checks PATH first, then known macOS/Linux install locations.
+ */
+function resolveCursorBin() {
+  // Check if cursor is on PATH
+  try {
+    execFileSync("cursor", ["--version"], { encoding: "utf8", timeout: 3000, stdio: "pipe" });
+    return "cursor";
+  } catch {
+    // Not on PATH — check common install locations
+  }
+
+  const candidates = [
+    // macOS: Cursor.app
+    "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+    // macOS: user-local
+    path.join(os.homedir(), "Applications", "Cursor.app", "Contents", "Resources", "app", "bin", "cursor"),
+    // Linux: common install paths
+    "/usr/share/cursor/bin/cursor",
+    "/opt/cursor/bin/cursor",
+    path.join(os.homedir(), ".local", "bin", "cursor"),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+let _cursorBin;
+function cursorBin() {
+  if (_cursorBin === undefined) _cursorBin = resolveCursorBin();
+  return _cursorBin;
+}
+
+/**
+ * Run a command and return stdout, or null on failure.
+ */
+function run(cmd, args, opts = {}) {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf8", timeout: 5000, stdio: "pipe", ...opts }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Spawn a command with inherited stdio (fire-and-forget for GUI apps).
+ */
+function open(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: "inherit" });
+    child.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited with ${code}`))));
+    child.on("error", reject);
+  });
+}
+
+/**
+ * Trigger Cursor's Composer (Cmd/Ctrl+I), paste the instruction, and submit.
+ * macOS: AppleScript, Linux: xdotool, Windows: PowerShell SendKeys.
+ */
+function triggerComposer(instruction, files) {
+  const prompt = [
+    instruction,
+    "",
+    "Target files:",
+    ...files.map((f) => `- ${f}`),
+  ].join("\n");
+
+  if (process.platform === "darwin") {
+    const escaped = prompt.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const script = `
+      delay 2
+      tell application "Cursor" to activate
+      delay 0.5
+      tell application "System Events"
+        tell process "Cursor"
+          keystroke "i" using {command down}
+          delay 0.8
+          set the clipboard to "${escaped}"
+          keystroke "v" using {command down}
+          delay 0.3
+          key code 36
+        end tell
+      end tell
+    `;
+    const child = spawn("osascript", ["-e", script], { stdio: "ignore", detached: true });
+    child.unref();
+  } else if (process.platform === "linux") {
+    // xdotool: wait for Cursor window, send Ctrl+I, type instruction, submit
+    const escaped = prompt.replace(/'/g, "'\\''");
+    const script = `
+      sleep 2
+      xdotool search --name "Cursor" windowactivate --sync
+      sleep 0.5
+      xdotool key ctrl+i
+      sleep 0.8
+      xdotool type --clearmodifiers -- '${escaped}'
+      sleep 0.3
+      xdotool key Return
+    `;
+    const child = spawn("bash", ["-c", script], { stdio: "ignore", detached: true });
+    child.unref();
+  } else if (process.platform === "win32") {
+    // PowerShell: activate Cursor, send Ctrl+I, paste, submit
+    const escaped = prompt.replace(/'/g, "''").replace(/`/g, "``");
+    const ps = `
+      Start-Sleep -Seconds 2
+      $wshell = New-Object -ComObject wscript.shell
+      $wshell.AppActivate('Cursor')
+      Start-Sleep -Milliseconds 500
+      $wshell.SendKeys('^i')
+      Start-Sleep -Milliseconds 800
+      Set-Clipboard '${escaped}'
+      $wshell.SendKeys('^v')
+      Start-Sleep -Milliseconds 300
+      $wshell.SendKeys('{ENTER}')
+    `;
+    const child = spawn("powershell", ["-NoProfile", "-Command", ps], { stdio: "ignore", detached: true });
+    child.unref();
+  }
+}
+
+/**
+ * Parse SKILL.md frontmatter → { meta, body }.
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!match) return { meta: {}, body: content };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^(\w+)\s*:\s*(.+)/);
+    if (kv) meta[kv[1]] = kv[2].trim();
+  }
+  return { meta, body: match[2] };
+}
+
+/**
+ * Collect all SKILL.md files from known locations.
+ * Returns array of { name, description, content }.
+ */
+function collectSkills() {
+  const skills = [];
+  const seen = new Set();
+
+  function scanDir(dir) {
+    if (!fs.existsSync(dir)) return;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillMd = path.join(dir, entry.name, "SKILL.md");
+        if (!fs.existsSync(skillMd)) continue;
+        const raw = fs.readFileSync(skillMd, "utf8");
+        const { meta, body } = parseFrontmatter(raw);
+        const name = meta.name || entry.name;
+        if (seen.has(name)) continue;
+        seen.add(name);
+        skills.push({ name, description: meta.description || "", content: body.trim() });
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // 1. Built-in CLI skills (resolve from the CLI entry point)
+  const cliSkillsDirs = [
+    process.argv[1] ? path.resolve(path.dirname(process.argv[1]), "src", "skills") : null,
+    path.resolve(os.homedir(), ".fops", "cli", "src", "skills"),
+  ].filter(Boolean);
+
+  for (const dir of cliSkillsDirs) {
+    scanDir(dir);
+  }
+
+  // 2. User skills ~/.fops/skills/
+  scanDir(path.join(os.homedir(), ".fops", "skills"));
+
+  // 3. Plugin skills ~/.fops/plugins/*/skills/
+  const pluginsDir = path.join(os.homedir(), ".fops", "plugins");
+  if (fs.existsSync(pluginsDir)) {
+    try {
+      const plugins = fs.readdirSync(pluginsDir, { withFileTypes: true });
+      for (const p of plugins) {
+        if (!p.isDirectory()) continue;
+        scanDir(path.join(pluginsDir, p.name, "skills"));
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Build .mdc frontmatter block.
+ */
+function mdcFrontmatter({ description, globs, alwaysApply }) {
+  const lines = ["---"];
+  if (description) lines.push(`description: ${description}`);
+  if (globs) lines.push(`globs: ${globs}`);
+  if (alwaysApply != null) lines.push(`alwaysApply: ${alwaysApply}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+
+/**
+ * Write .cursorrules + .cursor/rules/fops-*.mdc from collected skills.
+ * Returns number of skills synced.
+ */
+function syncRules(cwd, skills) {
+  if (skills.length === 0) return 0;
+
+  // Write concatenated .cursorrules
+  const combined = skills
+    .map((s) => `# ${s.name}\n\n${s.content}`)
+    .join("\n\n---\n\n");
+  fs.writeFileSync(path.join(cwd, ".cursorrules"), combined, "utf8");
+
+  // Write individual .cursor/rules/fops-<name>.mdc files
+  const rulesDir = path.join(cwd, ".cursor", "rules");
+  fs.mkdirSync(rulesDir, { recursive: true });
+
+  for (const skill of skills) {
+    const safeName = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const front = mdcFrontmatter({
+      description: skill.description || skill.name,
+      alwaysApply: true,
+    });
+    fs.writeFileSync(path.join(rulesDir, `fops-${safeName}.mdc`), `${front}\n\n${skill.content}\n`, "utf8");
+  }
+
+  return skills.length;
+}
+
+export function register(api) {
+  // ── Doctor check ──────────────────────────────────
+  api.registerDoctorCheck({
+    name: "Cursor IDE",
+    fn: async (ok, warn) => {
+      const bin = cursorBin();
+      if (bin) {
+        const version = run(bin, ["--version"]);
+        ok("Cursor IDE", version || bin);
+      } else {
+        warn("Cursor IDE", "not found — install from cursor.com, then: Cmd+Shift+P → Shell Command: Install 'cursor'");
+      }
+    },
+  });
+
+  // ── Auto-run patterns (agent executes these immediately) ──
+  api.registerAutoRunPattern("fops cursor open");
+  api.registerAutoRunPattern("fops cursor edit");
+  api.registerAutoRunPattern("fops cursor rules sync");
+
+  // ── Commands ──────────────────────────────────────
+  api.registerCommand((program) => {
+    const cursor = program
+      .command("cursor")
+      .description("Cursor IDE integration — open files, sync rules, edit with AI");
+
+    // fops cursor open [path] [-g line]
+    cursor
+      .command("open [path]")
+      .description("Open file or folder in Cursor")
+      .option("-g <line>", "Go to line number")
+      .action(async (targetPath, opts) => {
+        const bin = cursorBin();
+        if (!bin) { console.error("Cursor CLI not found. Install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"); process.exit(1); }
+        const target = targetPath || ".";
+        const args = [];
+        if (opts.g) args.push("-g", `${target}:${opts.g}`);
+        else args.push(target);
+        try {
+          await open(bin, args);
+        } catch (err) {
+          console.error(`Failed to open Cursor: ${err.message}`);
+          process.exit(1);
+        }
+      });
+
+    // fops cursor rules sync | show | clean
+    const rules = cursor
+      .command("rules")
+      .description("Manage Cursor AI rules synced from fops skills");
+
+    rules
+      .command("sync")
+      .description("Sync all fops skills into .cursorrules and .cursor/rules/")
+      .action(async () => {
+        const cwd = process.cwd();
+        const skills = collectSkills();
+
+        if (skills.length === 0) {
+          console.log("No skills found to sync.");
+          return;
+        }
+
+        syncRules(cwd, skills);
+
+        console.log(`Synced ${skills.length} skill(s):`);
+        for (const s of skills) {
+          console.log(`  - ${s.name}`);
+        }
+        console.log(`\nWrote .cursorrules and ${skills.length} .cursor/rules/fops-*.mdc file(s).`);
+      });
+
+    rules
+      .command("show")
+      .description("Display current .cursorrules and .cursor/rules/*.mdc files")
+      .action(async () => {
+        const cwd = process.cwd();
+        const cursorrules = path.join(cwd, ".cursorrules");
+
+        if (fs.existsSync(cursorrules)) {
+          console.log("── .cursorrules ──");
+          console.log(fs.readFileSync(cursorrules, "utf8"));
+        } else {
+          console.log("No .cursorrules file found. Run: fops cursor rules sync");
+        }
+
+        const rulesDir = path.join(cwd, ".cursor", "rules");
+        if (fs.existsSync(rulesDir)) {
+          try {
+            const files = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".mdc"));
+            if (files.length > 0) {
+              console.log("\n── .cursor/rules/*.mdc ──");
+              for (const f of files) {
+                console.log(`  ${f}`);
+              }
+            }
+          } catch {
+            // ignore
+          }
+        }
+      });
+
+    rules
+      .command("clean")
+      .description("Remove .cursorrules and fops-generated .cursor/rules/fops-*.mdc files")
+      .action(async () => {
+        const cwd = process.cwd();
+        let removed = 0;
+
+        const cursorrules = path.join(cwd, ".cursorrules");
+        if (fs.existsSync(cursorrules)) {
+          fs.unlinkSync(cursorrules);
+          console.log("Removed .cursorrules");
+          removed++;
+        }
+
+        const rulesDir = path.join(cwd, ".cursor", "rules");
+        if (fs.existsSync(rulesDir)) {
+          try {
+            const files = fs.readdirSync(rulesDir).filter((f) => f.startsWith("fops-") && f.endsWith(".mdc"));
+            for (const f of files) {
+              fs.unlinkSync(path.join(rulesDir, f));
+              console.log(`Removed .cursor/rules/${f}`);
+              removed++;
+            }
+          } catch {
+            // ignore
+          }
+        }
+
+        if (removed === 0) console.log("Nothing to clean.");
+        else console.log(`\nRemoved ${removed} file(s).`);
+      });
+
+    // fops cursor edit <files...> -m <instruction> [--rules-sync]
+    cursor
+      .command("edit <files...>")
+      .description("Open files in Cursor with a task-specific AI instruction")
+      .requiredOption("-m, --message <instruction>", "AI instruction for the task")
+      .option("--rules-sync", "Sync fops skills into .cursorrules before opening")
+      .action(async (files, opts) => {
+        const cwd = process.cwd();
+
+        // Auto-sync rules if flag is set or .cursorrules doesn't exist
+        if (opts.rulesSync || !fs.existsSync(path.join(cwd, ".cursorrules"))) {
+          const skills = collectSkills();
+          const count = syncRules(cwd, skills);
+          if (count > 0) {
+            console.log(`Synced ${count} skill(s) into .cursorrules`);
+          }
+        }
+
+        // Create task-specific rule
+        const rulesDir = path.join(cwd, ".cursor", "rules");
+        fs.mkdirSync(rulesDir, { recursive: true });
+
+        const globs = files.join(", ");
+        const front = mdcFrontmatter({
+          description: opts.message,
+          globs,
+          alwaysApply: true,
+        });
+        const body = [
+          "## Task",
+          "",
+          opts.message,
+          "",
+          "## Target files",
+          "",
+          ...files.map((f) => `- ${f}`),
+          "",
+          "Read the target files above and apply the instruction.",
+        ].join("\n");
+
+        fs.writeFileSync(path.join(rulesDir, "fops-task.mdc"), `${front}\n\n${body}\n`, "utf8");
+        console.log("Created .cursor/rules/fops-task.mdc");
+
+        // Open files in Cursor and trigger Composer with instruction
+        const bin = cursorBin();
+        if (!bin) { console.error("Cursor CLI not found. Install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"); process.exit(1); }
+        try {
+          await open(bin, files);
+          triggerComposer(opts.message, files);
+        } catch (err) {
+          console.error(`Failed to open Cursor: ${err.message}`);
+          process.exit(1);
+        }
+      });
+  });
+}

package/src/plugins/bundled/cursor/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/src/plugins/bundled/cursor/skills/cursor/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: cursor
+description: Cursor IDE integration — open files, sync AI rules, edit with instructions
+requires: cursor
+---
+
+## Cursor IDE Commands
+
+The `fops cursor` commands bridge fops knowledge into Cursor's AI via `.cursorrules` and `.cursor/rules/*.mdc` files.
+
+**IMPORTANT: When the user asks to edit code, open a file, or work on something in Cursor — DO NOT just suggest the command. Output the `fops cursor edit` or `fops cursor open` command in a bash block and it will execute automatically.** Be direct: "Opening in Cursor..." not "you could run...".
+
+### When to act
+
+- User says "edit X", "fix X", "refactor X", "open X in cursor" → immediately output `fops cursor edit <files> -m "<instruction>"`
+- User says "open X" or "open in cursor" → immediately output `fops cursor open <path>`
+- User asks to modify code with AI → `fops cursor edit`
+
+### Open files in Cursor
+
+```bash
+fops cursor open                     # open current directory
+fops cursor open src/api.py          # open a specific file
+fops cursor open src/api.py -g 42    # open at a specific line
+```
+
+### Sync fops skills as Cursor rules
+
+```bash
+fops cursor rules sync    # write all fops skills to .cursorrules + .cursor/rules/fops-*.mdc
+fops cursor rules show    # display current rules
+fops cursor rules clean   # remove fops-generated rules (keeps user-authored .mdc files)
+```
+
+### Edit with AI instructions
+
+```bash
+fops cursor edit src/agent/context.js -m "add error handling for missing skills"
+fops cursor edit src/api.py src/models.py -m "add pagination to the list endpoint"
+```
+
+This creates a `.cursor/rules/fops-task.mdc` with the instruction and target files, then opens them in Cursor. If `.cursorrules` doesn't exist yet, it auto-syncs rules first.
+
+Use `--rules-sync` to force a fresh rules sync before opening:
+
+```bash
+fops cursor edit src/api.py -m "refactor auth" --rules-sync
+```

package/src/plugins/bundled/fops-plugin-1password/fops.plugin.json

@@ -0,0 +1,7 @@
+{
+  "id": "fops-plugin-1password",
+  "name": "1Password Secrets",
+  "version": "0.1.0",
+  "description": "Inject secrets from 1Password into .env files using op:// references",
+  "skills": ["skills/1password"]
+}