cursor-kit-cli 1.0.4-beta.2 → 1.1.0-beta.3

package/dist/cli.js

@@ -2,6 +2,7 @@
 
 // src/cli.ts
 import { defineCommand as defineCommand6, runMain } from "citty";
+import { createRequire } from "module";
 
 // src/utils/branding.ts
 import figlet from "figlet";
@@ -31,7 +32,7 @@ function printDivider() {
 }
 function printVersion(version) {
   console.log(
-    pc.dim("  v") + cursorGradient(version) + pc.dim(" \u2022 Made with \u2665")
+    pc.dim("  ") + cursorGradient(`v${version}`) + pc.dim(" \u2022 Made with \u2665")
   );
   console.log();
 }
@@ -43,7 +44,7 @@ function highlight(text2) {
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 import pc2 from "picocolors";
-import { downloadTemplate } from "giget";
+import { join as join3 } from "path";
 
 // src/utils/fs.ts
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync, statSync } from "fs";
@@ -88,12 +89,190 @@ function getCommandsDir(cwd = process.cwd()) {
 function getRulesDir(cwd = process.cwd()) {
   return join(getCursorDir(cwd), "rules");
 }
+function getConflictingFiles(dir, files) {
+  if (!dirExists(dir)) return [];
+  return files.filter((file) => fileExists(join(dir, file)));
+}
+
+// src/utils/templates.ts
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
 
 // src/utils/constants.ts
 var REPO_URL = "github:duongductrong/cursor-kit";
 var REPO_REF = "master";
+var REPO_RAW_URL = "https://raw.githubusercontent.com/duongductrong/cursor-kit/master";
+var TEMPLATE_PATHS = {
+  commands: "templates/commands",
+  rules: "templates/rules"
+};
+
+// src/utils/templates.ts
+function getLocalTemplatesDir() {
+  const currentDir = dirname2(fileURLToPath(import.meta.url));
+  return join2(currentDir, "..", "templates");
+}
+function getLocalManifest() {
+  const templatesDir = getLocalTemplatesDir();
+  const manifestPath = join2(templatesDir, "manifest.json");
+  if (fileExists(manifestPath)) {
+    try {
+      return JSON.parse(readFile(manifestPath));
+    } catch {
+      return null;
+    }
+  }
+  const commandsDir = join2(templatesDir, "commands");
+  const rulesDir = join2(templatesDir, "rules");
+  if (!dirExists(commandsDir) && !dirExists(rulesDir)) {
+    return null;
+  }
+  return {
+    commands: dirExists(commandsDir) ? listFiles(commandsDir, ".md") : [],
+    rules: dirExists(rulesDir) ? listFiles(rulesDir, ".mdc") : []
+  };
+}
+function getLocalTemplateContent(type, filename) {
+  const templatesDir = getLocalTemplatesDir();
+  const filePath = join2(templatesDir, type, filename);
+  if (fileExists(filePath)) {
+    return readFile(filePath);
+  }
+  return null;
+}
+async function fetchTemplateManifest() {
+  const localManifest = getLocalManifest();
+  if (localManifest) {
+    return localManifest;
+  }
+  const url = `${REPO_RAW_URL}/templates/manifest.json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch template manifest: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function fetchTemplateContent(type, filename) {
+  const localContent = getLocalTemplateContent(type, filename);
+  if (localContent !== null) {
+    return localContent;
+  }
+  const templatePath = TEMPLATE_PATHS[type];
+  const url = `${REPO_RAW_URL}/${templatePath}/${filename}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch template ${filename}: ${response.statusText}`);
+  }
+  return response.text();
+}
+async function fetchMultipleTemplates(type, filenames) {
+  const results = /* @__PURE__ */ new Map();
+  const fetchPromises = filenames.map(async (filename) => {
+    const content = await fetchTemplateContent(type, filename);
+    return { filename, content };
+  });
+  const settled = await Promise.allSettled(fetchPromises);
+  for (const result of settled) {
+    if (result.status === "fulfilled") {
+      results.set(result.value.filename, result.value.content);
+    }
+  }
+  return results;
+}
+function getTemplateLabel(filename) {
+  const nameWithoutExt = filename.replace(/\.(md|mdc)$/, "");
+  return nameWithoutExt.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
 
 // src/commands/init.ts
+async function selectTemplates(type, availableTemplates) {
+  const selectionMode = await p.select({
+    message: `How would you like to add ${type}?`,
+    options: [
+      {
+        value: "all",
+        label: `Add all ${availableTemplates.length} ${type}`,
+        hint: "Install everything"
+      },
+      {
+        value: "select",
+        label: "Select specific items",
+        hint: "Choose which ones to install"
+      }
+    ]
+  });
+  if (p.isCancel(selectionMode)) return selectionMode;
+  if (selectionMode === "all") {
+    return availableTemplates;
+  }
+  const selectedTemplates = await p.multiselect({
+    message: `Select ${type} to add:`,
+    options: availableTemplates.map((template) => ({
+      value: template,
+      label: getTemplateLabel(template),
+      hint: template
+    })),
+    required: true
+  });
+  return selectedTemplates;
+}
+async function handleConflicts(type, conflictingFiles) {
+  console.log();
+  console.log(
+    pc2.yellow(`\u26A0 ${conflictingFiles.length} existing ${type} found:`)
+  );
+  for (const file of conflictingFiles) {
+    console.log(pc2.dim(`   \u2514\u2500 ${file}`));
+  }
+  console.log();
+  const strategy = await p.select({
+    message: "How would you like to handle conflicts?",
+    options: [
+      {
+        value: "overwrite",
+        label: "Overwrite existing files",
+        hint: "Replace all conflicting files"
+      },
+      {
+        value: "merge",
+        label: "Merge (keep existing, add new only)",
+        hint: "Skip files that already exist"
+      },
+      {
+        value: "cancel",
+        label: "Cancel",
+        hint: "Abort the operation"
+      }
+    ]
+  });
+  return strategy;
+}
+async function installTemplates(type, targetDir, selectedTemplates, conflictStrategy) {
+  const result = { added: [], skipped: [] };
+  const conflictingFiles = getConflictingFiles(targetDir, selectedTemplates);
+  let templatesToInstall;
+  if (conflictStrategy === "merge") {
+    templatesToInstall = selectedTemplates.filter(
+      (t) => !conflictingFiles.includes(t)
+    );
+    result.skipped = conflictingFiles.filter(
+      (f) => selectedTemplates.includes(f)
+    );
+  } else {
+    templatesToInstall = selectedTemplates;
+  }
+  if (templatesToInstall.length === 0) {
+    return result;
+  }
+  const templates = await fetchMultipleTemplates(type, templatesToInstall);
+  ensureDir(targetDir);
+  for (const [filename, content] of templates) {
+    const filePath = join3(targetDir, filename);
+    writeFile(filePath, content);
+    result.added.push(filename);
+  }
+  return result;
+}
 var initCommand = defineCommand({
   meta: {
     name: "init",
@@ -103,7 +282,7 @@ var initCommand = defineCommand({
     force: {
       type: "boolean",
       alias: "f",
-      description: "Overwrite existing files",
+      description: "Overwrite existing files without prompting",
       default: false
     },
     commands: {
@@ -117,6 +296,12 @@ var initCommand = defineCommand({
       alias: "r",
       description: "Only initialize rules",
       default: false
+    },
+    all: {
+      type: "boolean",
+      alias: "a",
+      description: "Install all templates without selection prompts",
+      default: false
     }
   },
   async run({ args }) {
@@ -128,62 +313,126 @@ var initCommand = defineCommand({
     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();
+    let manifest;
+    try {
+      s.start("Fetching template manifest...");
+      manifest = await fetchTemplateManifest();
+      s.stop("Template manifest loaded");
+    } catch (error) {
+      s.stop("Failed to fetch manifest");
+      p.cancel(
+        `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+    const results = {};
     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");
+        let selectedCommands;
+        if (args.all) {
+          selectedCommands = manifest.commands;
+        } else {
+          const selection = await selectTemplates("commands", manifest.commands);
+          if (p.isCancel(selection)) {
+            p.cancel("Operation cancelled");
+            process.exit(0);
+          }
+          selectedCommands = selection;
+        }
+        const conflictingCommands = getConflictingFiles(
+          commandsDir,
+          selectedCommands
+        );
+        let commandStrategy = "overwrite";
+        if (conflictingCommands.length > 0 && !args.force) {
+          const strategy = await handleConflicts("commands", conflictingCommands);
+          if (p.isCancel(strategy) || strategy === "cancel") {
+            p.cancel("Operation cancelled");
+            process.exit(0);
+          }
+          commandStrategy = strategy;
+        }
+        s.start("Installing commands...");
+        results.commands = await installTemplates(
+          "commands",
+          commandsDir,
+          selectedCommands,
+          commandStrategy
+        );
+        s.stop("Commands installed");
       }
       if (shouldInitRules) {
-        s.start("Fetching rules templates...");
-        await downloadTemplate(`${REPO_URL}/templates/rules#${REPO_REF}`, {
-          dir: rulesDir,
-          force: true
-        });
-        s.stop("Rules initialized");
+        let selectedRules;
+        if (args.all) {
+          selectedRules = manifest.rules;
+        } else {
+          const selection = await selectTemplates("rules", manifest.rules);
+          if (p.isCancel(selection)) {
+            p.cancel("Operation cancelled");
+            process.exit(0);
+          }
+          selectedRules = selection;
+        }
+        const conflictingRules = getConflictingFiles(rulesDir, selectedRules);
+        let ruleStrategy = "overwrite";
+        if (conflictingRules.length > 0 && !args.force) {
+          const strategy = await handleConflicts("rules", conflictingRules);
+          if (p.isCancel(strategy) || strategy === "cancel") {
+            p.cancel("Operation cancelled");
+            process.exit(0);
+          }
+          ruleStrategy = strategy;
+        }
+        s.start("Installing rules...");
+        results.rules = await installTemplates(
+          "rules",
+          rulesDir,
+          selectedRules,
+          ruleStrategy
+        );
+        s.stop("Rules installed");
       }
       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 (results.commands) {
+        const { added, skipped } = results.commands;
+        if (added.length > 0 || skipped.length > 0) {
+          printSuccess(
+            `Commands: ${highlight(added.length.toString())} added${skipped.length > 0 ? `, ${pc2.yellow(skipped.length.toString())} skipped` : ""}`
+          );
+          for (const f of added) {
+            console.log(pc2.dim(`   \u2514\u2500 ${pc2.green("+")} ${f}`));
+          }
+          for (const f of skipped) {
+            console.log(pc2.dim(`   \u2514\u2500 ${pc2.yellow("\u25CB")} ${f} (kept existing)`));
+          }
+        }
       }
-      if (shouldInitRules && ruleFiles.length > 0) {
-        printSuccess(
-          `Rules: ${highlight(ruleFiles.length.toString())} templates`
-        );
-        ruleFiles.forEach((f) => {
-          console.log(pc2.dim(`   \u2514\u2500 ${f}`));
-        });
+      if (results.rules) {
+        const { added, skipped } = results.rules;
+        if (added.length > 0 || skipped.length > 0) {
+          printSuccess(
+            `Rules: ${highlight(added.length.toString())} added${skipped.length > 0 ? `, ${pc2.yellow(skipped.length.toString())} skipped` : ""}`
+          );
+          for (const f of added) {
+            console.log(pc2.dim(`   \u2514\u2500 ${pc2.green("+")} ${f}`));
+          }
+          for (const f of skipped) {
+            console.log(pc2.dim(`   \u2514\u2500 ${pc2.yellow("\u25CB")} ${f} (kept existing)`));
+          }
+        }
+      }
+      const totalAdded = (results.commands?.added.length ?? 0) + (results.rules?.added.length ?? 0);
+      const totalSkipped = (results.commands?.skipped.length ?? 0) + (results.rules?.skipped.length ?? 0);
+      if (totalAdded === 0 && totalSkipped > 0) {
+        console.log();
+        p.outro(pc2.yellow("No new templates added (all selected files already exist)"));
+      } else {
+        console.log();
+        p.outro(pc2.green("\u2728 Cursor Kit initialized successfully!"));
       }
-      console.log();
-      p.outro(pc2.green("\u2728 Cursor Kit initialized successfully!"));
     } catch (error) {
       s.stop("Failed");
       p.cancel(
@@ -198,7 +447,7 @@ var initCommand = defineCommand({
 import { defineCommand as defineCommand2 } from "citty";
 import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 var COMMAND_TEMPLATE = `You are a helpful assistant. Describe what this command does.
 
 ## Instructions
@@ -295,7 +544,7 @@ var addCommand = defineCommand2({
     const isCommand = itemType === "command";
     const targetDir = isCommand ? getCommandsDir() : getRulesDir();
     const extension = isCommand ? ".md" : ".mdc";
-    const filePath = join2(targetDir, `${slug}${extension}`);
+    const filePath = join4(targetDir, `${slug}${extension}`);
     if (fileExists(filePath)) {
       const shouldOverwrite = await p2.confirm({
         message: `${highlight(slug + extension)} already exists. Overwrite?`,
@@ -331,7 +580,7 @@ var addCommand = defineCommand2({
 import { defineCommand as defineCommand3 } from "citty";
 import * as p3 from "@clack/prompts";
 import pc4 from "picocolors";
-import { downloadTemplate as downloadTemplate2 } from "giget";
+import { downloadTemplate } from "giget";
 var pullCommand = defineCommand3({
   meta: {
     name: "pull",
@@ -390,7 +639,7 @@ var pullCommand = defineCommand3({
       ensureDir(getCursorDir());
       if (shouldPullCommands) {
         s.start("Pulling commands...");
-        await downloadTemplate2(`${REPO_URL}/templates/commands#${REPO_REF}`, {
+        await downloadTemplate(`${REPO_URL}/templates/commands#${REPO_REF}`, {
           dir: commandsDir,
           force: true
         });
@@ -398,7 +647,7 @@ var pullCommand = defineCommand3({
       }
       if (shouldPullRules) {
         s.start("Pulling rules...");
-        await downloadTemplate2(`${REPO_URL}/templates/rules#${REPO_REF}`, {
+        await downloadTemplate(`${REPO_URL}/templates/rules#${REPO_REF}`, {
           dir: rulesDir,
           force: true
         });
@@ -434,7 +683,7 @@ var pullCommand = defineCommand3({
 import { defineCommand as defineCommand4 } from "citty";
 import * as p4 from "@clack/prompts";
 import pc5 from "picocolors";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 function extractDescription(content, isCommand) {
   if (isCommand) {
     const firstLine = content.trim().split("\n")[0];
@@ -452,7 +701,7 @@ function extractDescription(content, isCommand) {
 function getItems(dir, extension, isCommand) {
   const files = listFiles(dir, extension);
   return files.map((file) => {
-    const filePath = join3(dir, file);
+    const filePath = join5(dir, file);
     const content = fileExists(filePath) ? readFile(filePath) : "";
     return {
       name: file.replace(extension, ""),
@@ -543,7 +792,7 @@ var listCommand = defineCommand4({
 import { defineCommand as defineCommand5 } from "citty";
 import * as p5 from "@clack/prompts";
 import pc6 from "picocolors";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var removeCommand = defineCommand5({
   meta: {
     name: "remove",
@@ -635,7 +884,7 @@ var removeCommand = defineCommand5({
       }
       itemName = nameResult;
     }
-    const filePath = join4(dir, `${itemName}${extension}`);
+    const filePath = join6(dir, `${itemName}${extension}`);
     if (!fileExists(filePath)) {
       p5.cancel(`${itemType} '${itemName}' not found`);
       process.exit(1);
@@ -664,15 +913,17 @@ var removeCommand = defineCommand5({
 });
 
 // src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
 var main = defineCommand6({
   meta: {
     name: "cursor-kit",
-    version: "0.1.0",
+    version: pkg.version,
     description: "CLI toolkit to manage Cursor IDE rules and commands"
   },
   setup() {
     printBanner();
-    printVersion("0.1.0");
+    printVersion(pkg.version);
   },
   subCommands: {
     init: initCommand,