cursor-kit-cli 1.0.3

package/dist/cli.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { defineCommand as defineCommand6, runMain } from "citty";
+
+// src/utils/branding.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+import pc from "picocolors";
+var cursorGradient = gradient(["#00DC82", "#36E4DA", "#0047E1"]);
+function printBanner() {
+  const banner = figlet.textSync("Cursor Kit", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted"
+  });
+  console.log(cursorGradient.multiline(banner));
+  console.log();
+  console.log(
+    pc.dim("  ") + pc.bold(pc.cyan("\u2726")) + pc.dim(" Supercharge your Cursor IDE with rules & commands")
+  );
+  console.log();
+}
+function printSuccess(message) {
+  console.log(pc.green("\u2713") + pc.dim(" ") + message);
+}
+function printInfo(message) {
+  console.log(pc.cyan("\u2139") + pc.dim(" ") + message);
+}
+function printDivider() {
+  console.log(pc.dim("\u2500".repeat(50)));
+}
+function printVersion(version) {
+  console.log(
+    pc.dim("  v") + cursorGradient(version) + pc.dim(" \u2022 Made with \u2665")
+  );
+  console.log();
+}
+function highlight(text2) {
+  return pc.cyan(text2);
+}
+
+// src/commands/init.ts
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+import { downloadTemplate } from "giget";
+
+// src/utils/fs.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function fileExists(path) {
+  return existsSync(path);
+}
+function dirExists(path) {
+  return existsSync(path) && statSync(path).isDirectory();
+}
+function readFile(path) {
+  return readFileSync(path, "utf-8");
+}
+function writeFile(path, content) {
+  ensureDir(dirname(path));
+  writeFileSync(path, content, "utf-8");
+}
+function removeFile(path) {
+  if (existsSync(path)) {
+    rmSync(path, { recursive: true });
+  }
+}
+function listFiles(dir, extension) {
+  if (!dirExists(dir)) return [];
+  const files = readdirSync(dir);
+  if (extension) {
+    return files.filter((f) => f.endsWith(extension));
+  }
+  return files;
+}
+function getCursorDir(cwd = process.cwd()) {
+  return join(cwd, ".cursor");
+}
+function getCommandsDir(cwd = process.cwd()) {
+  return join(getCursorDir(cwd), "commands");
+}
+function getRulesDir(cwd = process.cwd()) {
+  return join(getCursorDir(cwd), "rules");
+}
+
+// src/utils/constants.ts
+var REPO_URL = "github:duongductrong/cursor-kit";
+var REPO_REF = "master";
+
+// src/commands/init.ts
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize .cursor/commands and .cursor/rules in your project"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      alias: "f",
+      description: "Overwrite existing files",
+      default: false
+    },
+    commands: {
+      type: "boolean",
+      alias: "c",
+      description: "Only initialize commands",
+      default: false
+    },
+    rules: {
+      type: "boolean",
+      alias: "r",
+      description: "Only initialize rules",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const cursorDir = getCursorDir(cwd);
+    const commandsDir = getCommandsDir(cwd);
+    const rulesDir = getRulesDir(cwd);
+    const initBoth = !args.commands && !args.rules;
+    const shouldInitCommands = initBoth || args.commands;
+    const shouldInitRules = initBoth || args.rules;
+    p.intro(pc2.bgCyan(pc2.black(" cursor-kit init ")));
+    const commandsExist = dirExists(commandsDir) && listFiles(commandsDir).length > 0;
+    const rulesExist = dirExists(rulesDir) && listFiles(rulesDir).length > 0;
+    if ((commandsExist || rulesExist) && !args.force) {
+      const existingItems = [];
+      if (commandsExist) existingItems.push("commands");
+      if (rulesExist) existingItems.push("rules");
+      const shouldContinue = await p.confirm({
+        message: `Existing ${existingItems.join(" and ")} found. Overwrite?`,
+        initialValue: false
+      });
+      if (p.isCancel(shouldContinue) || !shouldContinue) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+    const s = p.spinner();
+    try {
+      ensureDir(cursorDir);
+      if (shouldInitCommands) {
+        s.start("Fetching commands templates...");
+        await downloadTemplate(`${REPO_URL}/templates/commands#${REPO_REF}`, {
+          dir: commandsDir,
+          force: true
+        });
+        s.stop("Commands initialized");
+      }
+      if (shouldInitRules) {
+        s.start("Fetching rules templates...");
+        await downloadTemplate(`${REPO_URL}/templates/rules#${REPO_REF}`, {
+          dir: rulesDir,
+          force: true
+        });
+        s.stop("Rules initialized");
+      }
+      printDivider();
+      console.log();
+      const commandFiles = listFiles(commandsDir, ".md");
+      const ruleFiles = listFiles(rulesDir, ".mdc");
+      if (shouldInitCommands && commandFiles.length > 0) {
+        printSuccess(
+          `Commands: ${highlight(commandFiles.length.toString())} templates`
+        );
+        commandFiles.forEach((f) => {
+          console.log(pc2.dim(`   \u2514\u2500 ${f}`));
+        });
+      }
+      if (shouldInitRules && ruleFiles.length > 0) {
+        printSuccess(
+          `Rules: ${highlight(ruleFiles.length.toString())} templates`
+        );
+        ruleFiles.forEach((f) => {
+          console.log(pc2.dim(`   \u2514\u2500 ${f}`));
+        });
+      }
+      console.log();
+      p.outro(pc2.green("\u2728 Cursor Kit initialized successfully!"));
+    } catch (error) {
+      s.stop("Failed");
+      p.cancel(
+        `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/add.ts
+import { defineCommand as defineCommand2 } from "citty";
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+import { join as join2 } from "path";
+var COMMAND_TEMPLATE = `You are a helpful assistant. Describe what this command does.
+
+## Instructions
+- Step 1: ...
+- Step 2: ...
+
+## Rules
+- Be concise
+- Focus on the task
+
+START: Wait for user input.
+`;
+var RULE_TEMPLATE = `---
+description: Describe when this rule should apply
+globs: 
+alwaysApply: false
+---
+
+# Rule Title
+
+Describe the rule behavior here.
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+`;
+function generateSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+var addCommand = defineCommand2({
+  meta: {
+    name: "add",
+    description: "Add a new command or rule"
+  },
+  args: {
+    type: {
+      type: "string",
+      alias: "t",
+      description: "Type: 'command' or 'rule'"
+    },
+    name: {
+      type: "string",
+      alias: "n",
+      description: "Name of the command or rule"
+    }
+  },
+  async run({ args }) {
+    p2.intro(pc3.bgCyan(pc3.black(" cursor-kit add ")));
+    let itemType;
+    let itemName;
+    if (args.type && ["command", "rule"].includes(args.type)) {
+      itemType = args.type;
+    } else {
+      const typeResult = await p2.select({
+        message: "What do you want to add?",
+        options: [
+          {
+            value: "command",
+            label: "Command",
+            hint: "A reusable prompt template"
+          },
+          {
+            value: "rule",
+            label: "Rule",
+            hint: "Project-specific AI behavior rules"
+          }
+        ]
+      });
+      if (p2.isCancel(typeResult)) {
+        p2.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      itemType = typeResult;
+    }
+    if (args.name) {
+      itemName = args.name;
+    } else {
+      const nameResult = await p2.text({
+        message: `Enter ${itemType} name:`,
+        placeholder: itemType === "command" ? "my-command" : "my-rule",
+        validate: (value) => {
+          if (!value.trim()) return "Name is required";
+          if (value.length < 2) return "Name must be at least 2 characters";
+          return void 0;
+        }
+      });
+      if (p2.isCancel(nameResult)) {
+        p2.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      itemName = nameResult;
+    }
+    const slug = generateSlug(itemName);
+    const isCommand = itemType === "command";
+    const targetDir = isCommand ? getCommandsDir() : getRulesDir();
+    const extension = isCommand ? ".md" : ".mdc";
+    const filePath = join2(targetDir, `${slug}${extension}`);
+    if (fileExists(filePath)) {
+      const shouldOverwrite = await p2.confirm({
+        message: `${highlight(slug + extension)} already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p2.isCancel(shouldOverwrite) || !shouldOverwrite) {
+        p2.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+    const s = p2.spinner();
+    s.start(`Creating ${itemType}...`);
+    try {
+      ensureDir(targetDir);
+      const template = isCommand ? COMMAND_TEMPLATE : RULE_TEMPLATE;
+      writeFile(filePath, template);
+      s.stop(`${itemType.charAt(0).toUpperCase() + itemType.slice(1)} created`);
+      console.log();
+      console.log(pc3.dim("  File: ") + highlight(filePath));
+      console.log();
+      p2.outro(
+        pc3.green(`\u2728 ${itemType.charAt(0).toUpperCase() + itemType.slice(1)} created! Edit the file to customize it.`)
+      );
+    } catch (error) {
+      s.stop("Failed");
+      p2.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/pull.ts
+import { defineCommand as defineCommand3 } from "citty";
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
+import { downloadTemplate as downloadTemplate2 } from "giget";
+var pullCommand = defineCommand3({
+  meta: {
+    name: "pull",
+    description: "Pull latest updates from cursor-kit repository"
+  },
+  args: {
+    commands: {
+      type: "boolean",
+      alias: "c",
+      description: "Only pull commands",
+      default: false
+    },
+    rules: {
+      type: "boolean",
+      alias: "r",
+      description: "Only pull rules",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      alias: "f",
+      description: "Force overwrite without confirmation",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const pullBoth = !args.commands && !args.rules;
+    const shouldPullCommands = pullBoth || args.commands;
+    const shouldPullRules = pullBoth || args.rules;
+    p3.intro(pc4.bgCyan(pc4.black(" cursor-kit pull ")));
+    const commandsDir = getCommandsDir();
+    const rulesDir = getRulesDir();
+    const existingCommands = listFiles(commandsDir, ".md");
+    const existingRules = listFiles(rulesDir, ".mdc");
+    const hasExisting = existingCommands.length > 0 || existingRules.length > 0;
+    if (hasExisting && !args.force) {
+      printInfo("Current status:");
+      if (existingCommands.length > 0) {
+        console.log(pc4.dim(`  Commands: ${existingCommands.length} files`));
+      }
+      if (existingRules.length > 0) {
+        console.log(pc4.dim(`  Rules: ${existingRules.length} files`));
+      }
+      console.log();
+      const shouldContinue = await p3.confirm({
+        message: "This will merge with existing files. Continue?",
+        initialValue: true
+      });
+      if (p3.isCancel(shouldContinue) || !shouldContinue) {
+        p3.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+    const s = p3.spinner();
+    try {
+      ensureDir(getCursorDir());
+      if (shouldPullCommands) {
+        s.start("Pulling commands...");
+        await downloadTemplate2(`${REPO_URL}/templates/commands#${REPO_REF}`, {
+          dir: commandsDir,
+          force: true
+        });
+        s.stop("Commands updated");
+      }
+      if (shouldPullRules) {
+        s.start("Pulling rules...");
+        await downloadTemplate2(`${REPO_URL}/templates/rules#${REPO_REF}`, {
+          dir: rulesDir,
+          force: true
+        });
+        s.stop("Rules updated");
+      }
+      printDivider();
+      console.log();
+      const newCommands = listFiles(commandsDir, ".md");
+      const newRules = listFiles(rulesDir, ".mdc");
+      if (shouldPullCommands) {
+        const added = newCommands.length - existingCommands.length;
+        printSuccess(
+          `Commands: ${highlight(newCommands.length.toString())} total` + (added > 0 ? pc4.green(` (+${added} new)`) : "")
+        );
+      }
+      if (shouldPullRules) {
+        const added = newRules.length - existingRules.length;
+        printSuccess(
+          `Rules: ${highlight(newRules.length.toString())} total` + (added > 0 ? pc4.green(` (+${added} new)`) : "")
+        );
+      }
+      console.log();
+      p3.outro(pc4.green("\u2728 Successfully pulled latest updates!"));
+    } catch (error) {
+      s.stop("Failed");
+      p3.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/list.ts
+import { defineCommand as defineCommand4 } from "citty";
+import * as p4 from "@clack/prompts";
+import pc5 from "picocolors";
+import { join as join3 } from "path";
+function extractDescription(content, isCommand) {
+  if (isCommand) {
+    const firstLine = content.trim().split("\n")[0];
+    if (firstLine && !firstLine.startsWith("#") && !firstLine.startsWith("---")) {
+      return firstLine.slice(0, 60) + (firstLine.length > 60 ? "..." : "");
+    }
+  } else {
+    const match = content.match(/description:\s*(.+)/);
+    if (match) {
+      return match[1].trim().slice(0, 60) + (match[1].length > 60 ? "..." : "");
+    }
+  }
+  return void 0;
+}
+function getItems(dir, extension, isCommand) {
+  const files = listFiles(dir, extension);
+  return files.map((file) => {
+    const filePath = join3(dir, file);
+    const content = fileExists(filePath) ? readFile(filePath) : "";
+    return {
+      name: file.replace(extension, ""),
+      path: filePath,
+      description: extractDescription(content, isCommand)
+    };
+  });
+}
+var listCommand = defineCommand4({
+  meta: {
+    name: "list",
+    description: "List all commands and rules"
+  },
+  args: {
+    commands: {
+      type: "boolean",
+      alias: "c",
+      description: "Only list commands",
+      default: false
+    },
+    rules: {
+      type: "boolean",
+      alias: "r",
+      description: "Only list rules",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      alias: "v",
+      description: "Show full file paths",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const listBoth = !args.commands && !args.rules;
+    const shouldListCommands = listBoth || args.commands;
+    const shouldListRules = listBoth || args.rules;
+    p4.intro(pc5.bgCyan(pc5.black(" cursor-kit list ")));
+    const commandsDir = getCommandsDir();
+    const rulesDir = getRulesDir();
+    const commands = shouldListCommands ? getItems(commandsDir, ".md", true) : [];
+    const rules = shouldListRules ? getItems(rulesDir, ".mdc", false) : [];
+    if (commands.length === 0 && rules.length === 0) {
+      console.log();
+      console.log(pc5.yellow("  No commands or rules found."));
+      console.log(pc5.dim("  Run ") + highlight("cursor-kit init") + pc5.dim(" to get started."));
+      console.log();
+      p4.outro(pc5.dim("Nothing to show"));
+      return;
+    }
+    printDivider();
+    if (shouldListCommands && commands.length > 0) {
+      console.log();
+      console.log(pc5.bold(pc5.cyan("  \u{1F4DC} Commands")) + pc5.dim(` (${commands.length})`));
+      console.log();
+      commands.forEach((cmd) => {
+        console.log(`  ${pc5.green("\u25CF")} ${highlight(cmd.name)}`);
+        if (cmd.description) {
+          console.log(pc5.dim(`    ${cmd.description}`));
+        }
+        if (args.verbose) {
+          console.log(pc5.dim(`    ${cmd.path}`));
+        }
+      });
+    }
+    if (shouldListRules && rules.length > 0) {
+      console.log();
+      console.log(pc5.bold(pc5.cyan("  \u{1F4CB} Rules")) + pc5.dim(` (${rules.length})`));
+      console.log();
+      rules.forEach((rule) => {
+        console.log(`  ${pc5.green("\u25CF")} ${highlight(rule.name)}`);
+        if (rule.description) {
+          console.log(pc5.dim(`    ${rule.description}`));
+        }
+        if (args.verbose) {
+          console.log(pc5.dim(`    ${rule.path}`));
+        }
+      });
+    }
+    console.log();
+    printDivider();
+    const total = commands.length + rules.length;
+    p4.outro(pc5.dim(`Total: ${total} item${total !== 1 ? "s" : ""}`));
+  }
+});
+
+// src/commands/remove.ts
+import { defineCommand as defineCommand5 } from "citty";
+import * as p5 from "@clack/prompts";
+import pc6 from "picocolors";
+import { join as join4 } from "path";
+var removeCommand = defineCommand5({
+  meta: {
+    name: "remove",
+    description: "Remove a command or rule"
+  },
+  args: {
+    type: {
+      type: "string",
+      alias: "t",
+      description: "Type: 'command' or 'rule'"
+    },
+    name: {
+      type: "string",
+      alias: "n",
+      description: "Name of the command or rule to remove"
+    },
+    force: {
+      type: "boolean",
+      alias: "f",
+      description: "Skip confirmation",
+      default: false
+    }
+  },
+  async run({ args }) {
+    p5.intro(pc6.bgCyan(pc6.black(" cursor-kit remove ")));
+    const commandsDir = getCommandsDir();
+    const rulesDir = getRulesDir();
+    const commands = listFiles(commandsDir, ".md").map((f) => f.replace(".md", ""));
+    const rules = listFiles(rulesDir, ".mdc").map((f) => f.replace(".mdc", ""));
+    if (commands.length === 0 && rules.length === 0) {
+      console.log();
+      console.log(pc6.yellow("  No commands or rules to remove."));
+      console.log();
+      p5.outro(pc6.dim("Nothing to do"));
+      return;
+    }
+    let itemType;
+    let itemName;
+    if (args.type && ["command", "rule"].includes(args.type)) {
+      itemType = args.type;
+    } else {
+      const typeOptions = [];
+      if (commands.length > 0) {
+        typeOptions.push({
+          value: "command",
+          label: "Command",
+          hint: `${commands.length} available`
+        });
+      }
+      if (rules.length > 0) {
+        typeOptions.push({
+          value: "rule",
+          label: "Rule",
+          hint: `${rules.length} available`
+        });
+      }
+      const typeResult = await p5.select({
+        message: "What do you want to remove?",
+        options: typeOptions
+      });
+      if (p5.isCancel(typeResult)) {
+        p5.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      itemType = typeResult;
+    }
+    const isCommand = itemType === "command";
+    const items = isCommand ? commands : rules;
+    const dir = isCommand ? commandsDir : rulesDir;
+    const extension = isCommand ? ".md" : ".mdc";
+    if (items.length === 0) {
+      p5.cancel(`No ${itemType}s found`);
+      process.exit(0);
+    }
+    if (args.name && items.includes(args.name)) {
+      itemName = args.name;
+    } else {
+      const itemOptions = items.map((item) => ({
+        value: item,
+        label: item
+      }));
+      const nameResult = await p5.select({
+        message: `Select ${itemType} to remove:`,
+        options: itemOptions
+      });
+      if (p5.isCancel(nameResult)) {
+        p5.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      itemName = nameResult;
+    }
+    const filePath = join4(dir, `${itemName}${extension}`);
+    if (!fileExists(filePath)) {
+      p5.cancel(`${itemType} '${itemName}' not found`);
+      process.exit(1);
+    }
+    if (!args.force) {
+      const shouldDelete = await p5.confirm({
+        message: `Are you sure you want to delete ${highlight(itemName + extension)}?`,
+        initialValue: false
+      });
+      if (p5.isCancel(shouldDelete) || !shouldDelete) {
+        p5.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+    try {
+      removeFile(filePath);
+      console.log();
+      printSuccess(`Removed ${highlight(itemName + extension)}`);
+      console.log();
+      p5.outro(pc6.green("\u2728 Done!"));
+    } catch (error) {
+      p5.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli.ts
+var main = defineCommand6({
+  meta: {
+    name: "cursor-kit",
+    version: "0.1.0",
+    description: "CLI toolkit to manage Cursor IDE rules and commands"
+  },
+  setup() {
+    printBanner();
+    printVersion("0.1.0");
+  },
+  subCommands: {
+    init: initCommand,
+    add: addCommand,
+    pull: pullCommand,
+    list: listCommand,
+    remove: removeCommand
+  }
+});
+runMain(main);
+//# sourceMappingURL=cli.js.map