cursor-kit-cli 1.0.3

package/dist/cli.cjs

@@ -0,0 +1,709 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_citty6 = require("citty");
+
+// src/utils/branding.ts
+var import_figlet = __toESM(require("figlet"), 1);
+var import_gradient_string = __toESM(require("gradient-string"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var cursorGradient = (0, import_gradient_string.default)(["#00DC82", "#36E4DA", "#0047E1"]);
+function printBanner() {
+  const banner = import_figlet.default.textSync("Cursor Kit", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted"
+  });
+  console.log(cursorGradient.multiline(banner));
+  console.log();
+  console.log(
+    import_picocolors.default.dim("  ") + import_picocolors.default.bold(import_picocolors.default.cyan("\u2726")) + import_picocolors.default.dim(" Supercharge your Cursor IDE with rules & commands")
+  );
+  console.log();
+}
+function printSuccess(message) {
+  console.log(import_picocolors.default.green("\u2713") + import_picocolors.default.dim(" ") + message);
+}
+function printInfo(message) {
+  console.log(import_picocolors.default.cyan("\u2139") + import_picocolors.default.dim(" ") + message);
+}
+function printDivider() {
+  console.log(import_picocolors.default.dim("\u2500".repeat(50)));
+}
+function printVersion(version) {
+  console.log(
+    import_picocolors.default.dim("  v") + cursorGradient(version) + import_picocolors.default.dim(" \u2022 Made with \u2665")
+  );
+  console.log();
+}
+function highlight(text2) {
+  return import_picocolors.default.cyan(text2);
+}
+
+// src/commands/init.ts
+var import_citty = require("citty");
+var p = __toESM(require("@clack/prompts"), 1);
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+var import_giget = require("giget");
+
+// src/utils/fs.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function ensureDir(path) {
+  if (!(0, import_node_fs.existsSync)(path)) {
+    (0, import_node_fs.mkdirSync)(path, { recursive: true });
+  }
+}
+function fileExists(path) {
+  return (0, import_node_fs.existsSync)(path);
+}
+function dirExists(path) {
+  return (0, import_node_fs.existsSync)(path) && (0, import_node_fs.statSync)(path).isDirectory();
+}
+function readFile(path) {
+  return (0, import_node_fs.readFileSync)(path, "utf-8");
+}
+function writeFile(path, content) {
+  ensureDir((0, import_node_path.dirname)(path));
+  (0, import_node_fs.writeFileSync)(path, content, "utf-8");
+}
+function removeFile(path) {
+  if ((0, import_node_fs.existsSync)(path)) {
+    (0, import_node_fs.rmSync)(path, { recursive: true });
+  }
+}
+function listFiles(dir, extension) {
+  if (!dirExists(dir)) return [];
+  const files = (0, import_node_fs.readdirSync)(dir);
+  if (extension) {
+    return files.filter((f) => f.endsWith(extension));
+  }
+  return files;
+}
+function getCursorDir(cwd = process.cwd()) {
+  return (0, import_node_path.join)(cwd, ".cursor");
+}
+function getCommandsDir(cwd = process.cwd()) {
+  return (0, import_node_path.join)(getCursorDir(cwd), "commands");
+}
+function getRulesDir(cwd = process.cwd()) {
+  return (0, import_node_path.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 = (0, import_citty.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(import_picocolors2.default.bgCyan(import_picocolors2.default.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 (0, import_giget.downloadTemplate)(`${REPO_URL}/templates/commands#${REPO_REF}`, {
+          dir: commandsDir,
+          force: true
+        });
+        s.stop("Commands initialized");
+      }
+      if (shouldInitRules) {
+        s.start("Fetching rules templates...");
+        await (0, import_giget.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(import_picocolors2.default.dim(`   \u2514\u2500 ${f}`));
+        });
+      }
+      if (shouldInitRules && ruleFiles.length > 0) {
+        printSuccess(
+          `Rules: ${highlight(ruleFiles.length.toString())} templates`
+        );
+        ruleFiles.forEach((f) => {
+          console.log(import_picocolors2.default.dim(`   \u2514\u2500 ${f}`));
+        });
+      }
+      console.log();
+      p.outro(import_picocolors2.default.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
+var import_citty2 = require("citty");
+var p2 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_node_path2 = require("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 = (0, import_citty2.defineCommand)({
+  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(import_picocolors3.default.bgCyan(import_picocolors3.default.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 = (0, import_node_path2.join)(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(import_picocolors3.default.dim("  File: ") + highlight(filePath));
+      console.log();
+      p2.outro(
+        import_picocolors3.default.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
+var import_citty3 = require("citty");
+var p3 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_giget2 = require("giget");
+var pullCommand = (0, import_citty3.defineCommand)({
+  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(import_picocolors4.default.bgCyan(import_picocolors4.default.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(import_picocolors4.default.dim(`  Commands: ${existingCommands.length} files`));
+      }
+      if (existingRules.length > 0) {
+        console.log(import_picocolors4.default.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 (0, import_giget2.downloadTemplate)(`${REPO_URL}/templates/commands#${REPO_REF}`, {
+          dir: commandsDir,
+          force: true
+        });
+        s.stop("Commands updated");
+      }
+      if (shouldPullRules) {
+        s.start("Pulling rules...");
+        await (0, import_giget2.downloadTemplate)(`${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 ? import_picocolors4.default.green(` (+${added} new)`) : "")
+        );
+      }
+      if (shouldPullRules) {
+        const added = newRules.length - existingRules.length;
+        printSuccess(
+          `Rules: ${highlight(newRules.length.toString())} total` + (added > 0 ? import_picocolors4.default.green(` (+${added} new)`) : "")
+        );
+      }
+      console.log();
+      p3.outro(import_picocolors4.default.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
+var import_citty4 = require("citty");
+var p4 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors5 = __toESM(require("picocolors"), 1);
+var import_node_path3 = require("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 = (0, import_node_path3.join)(dir, file);
+    const content = fileExists(filePath) ? readFile(filePath) : "";
+    return {
+      name: file.replace(extension, ""),
+      path: filePath,
+      description: extractDescription(content, isCommand)
+    };
+  });
+}
+var listCommand = (0, import_citty4.defineCommand)({
+  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(import_picocolors5.default.bgCyan(import_picocolors5.default.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(import_picocolors5.default.yellow("  No commands or rules found."));
+      console.log(import_picocolors5.default.dim("  Run ") + highlight("cursor-kit init") + import_picocolors5.default.dim(" to get started."));
+      console.log();
+      p4.outro(import_picocolors5.default.dim("Nothing to show"));
+      return;
+    }
+    printDivider();
+    if (shouldListCommands && commands.length > 0) {
+      console.log();
+      console.log(import_picocolors5.default.bold(import_picocolors5.default.cyan("  \u{1F4DC} Commands")) + import_picocolors5.default.dim(` (${commands.length})`));
+      console.log();
+      commands.forEach((cmd) => {
+        console.log(`  ${import_picocolors5.default.green("\u25CF")} ${highlight(cmd.name)}`);
+        if (cmd.description) {
+          console.log(import_picocolors5.default.dim(`    ${cmd.description}`));
+        }
+        if (args.verbose) {
+          console.log(import_picocolors5.default.dim(`    ${cmd.path}`));
+        }
+      });
+    }
+    if (shouldListRules && rules.length > 0) {
+      console.log();
+      console.log(import_picocolors5.default.bold(import_picocolors5.default.cyan("  \u{1F4CB} Rules")) + import_picocolors5.default.dim(` (${rules.length})`));
+      console.log();
+      rules.forEach((rule) => {
+        console.log(`  ${import_picocolors5.default.green("\u25CF")} ${highlight(rule.name)}`);
+        if (rule.description) {
+          console.log(import_picocolors5.default.dim(`    ${rule.description}`));
+        }
+        if (args.verbose) {
+          console.log(import_picocolors5.default.dim(`    ${rule.path}`));
+        }
+      });
+    }
+    console.log();
+    printDivider();
+    const total = commands.length + rules.length;
+    p4.outro(import_picocolors5.default.dim(`Total: ${total} item${total !== 1 ? "s" : ""}`));
+  }
+});
+
+// src/commands/remove.ts
+var import_citty5 = require("citty");
+var p5 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors6 = __toESM(require("picocolors"), 1);
+var import_node_path4 = require("path");
+var removeCommand = (0, import_citty5.defineCommand)({
+  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(import_picocolors6.default.bgCyan(import_picocolors6.default.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(import_picocolors6.default.yellow("  No commands or rules to remove."));
+      console.log();
+      p5.outro(import_picocolors6.default.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 = (0, import_node_path4.join)(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(import_picocolors6.default.green("\u2728 Done!"));
+    } catch (error) {
+      p5.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli.ts
+var main = (0, import_citty6.defineCommand)({
+  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
+  }
+});
+(0, import_citty6.runMain)(main);
+//# sourceMappingURL=cli.cjs.map