@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/add/add-local/tool/oxlint.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @see https://oxc.rs/docs/guide/usage/linter.html
+ */
+export declare function useOxlintTool(): void;

package/bin/app/add/add-local/tool/oxlint.js

@@ -0,0 +1,4 @@
+import { relinka } from "@reliverse/relinka";
+export function useOxlintTool() {
+  relinka("info", "This integration is currently in development. Please check back later.");
+}

package/bin/app/add/add-local/ui/21st.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @see https://21st.dev
+ */
+export declare function use21stUI(): void;

package/bin/app/add/add-local/ui/21st.js

@@ -0,0 +1,4 @@
+import { relinka } from "@reliverse/relinka";
+export function use21stUI() {
+  relinka("info", "This integration is currently in development. Please check back later.");
+}

package/bin/app/add/add-local/ui/shadcn.d.ts

@@ -0,0 +1 @@
+export declare function useShadcnUI(): void;

package/bin/app/add/add-local/ui/shadcn.js

@@ -0,0 +1,4 @@
+import { relinka } from "@reliverse/relinka";
+export function useShadcnUI() {
+  relinka("info", "This integration is currently in development. Please check back later.");
+}

package/bin/app/add/add-local/ui/tailwind.d.ts

@@ -0,0 +1 @@
+export declare function useTailwindCSS(): void;

package/bin/app/add/add-local/ui/tailwind.js

@@ -0,0 +1,4 @@
+import { relinka } from "@reliverse/relinka";
+export function useTailwindCSS() {
+  relinka("info", "This integration is currently in development. Please check back later.");
+}

package/bin/app/add/add-rule/add-rule-const.d.ts

@@ -0,0 +1,11 @@
+import type { RuleRepo } from "./add-rule-types";
+export declare const CACHE_ROOT_DIR: string;
+export declare const DEFAULT_BRANCH = "main";
+export declare const RULE_FILE_EXTENSION = ".mdc";
+/**
+ * Returns the cache directory for a given repository owner.
+ * @param owner - The repository owner.
+ * @returns The cache directory path.
+ */
+export declare function getRepoCacheDir(owner: string): string;
+export declare const RULES_REPOS: RuleRepo[];

package/bin/app/add/add-rule/add-rule-const.js

@@ -0,0 +1,32 @@
+import path from "@reliverse/pathkit";
+import { homeDir } from "../../config/constants.js";
+export const CACHE_ROOT_DIR = path.join(homeDir, ".rse", "rules");
+export const DEFAULT_BRANCH = "main";
+export const RULE_FILE_EXTENSION = ".mdc";
+export function getRepoCacheDir(owner) {
+  return path.join(CACHE_ROOT_DIR, owner);
+}
+export const RULES_REPOS = [
+  {
+    id: "blefnk/awesome-cursor-rules",
+    author: "blefnk",
+    name: "rse Rules",
+    description: "AI IDE rules (Cursor, Windsurf, Copilot)",
+    branch: "main",
+    tags: ["cursor", "windsurf", "copilot"],
+    category: "ide",
+    isOfficial: true
+  },
+  {
+    id: "pontusab/directories",
+    author: "pontusab",
+    name: "Community Rules",
+    description: "Community-contributed AI IDE rules",
+    branch: "main",
+    tags: ["community", "cursor"],
+    category: "ide",
+    isOfficial: false,
+    isCommunity: true,
+    communityPath: "packages/data/src/rules"
+  }
+];

package/bin/app/add/add-rule/add-rule-impl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Called when the user passes `--get <names>` or `--get all`.
+ * Skips the interactive selection.
+ */
+export declare function handleDirectRules(opts: {
+    cwd: string;
+    isDev: boolean;
+    source: "official" | "community" | "prompt";
+    ruleNames: string[];
+}): Promise<void>;
+/**
+ * Main menu handler for the rules command.
+ * If `source` is "prompt", we display the interactive menu.
+ * If `source` is "official" or "community", we skip the menu
+ * and download from that source directly.
+ */
+export declare function showRulesMenu({ cwd, isDev, source, }: {
+    cwd: string;
+    isDev: boolean;
+    source: "official" | "community" | "prompt";
+}): Promise<void>;

package/bin/app/add/add-rule/add-rule-impl.js

@@ -0,0 +1,300 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, multiselectPrompt, selectPrompt } from "@reliverse/rempts";
+import { ofetch } from "ofetch";
+import {
+  DEFAULT_BRANCH,
+  getRepoCacheDir,
+  RULE_FILE_EXTENSION,
+  RULES_REPOS
+} from "./add-rule-const.js";
+import {
+  convertTsToMdc,
+  downloadRules,
+  handleRuleUpdates,
+  hasInstalledRules,
+  installRules
+} from "./add-rule-utils.js";
+export async function handleDirectRules(opts) {
+  const { cwd, source, ruleNames } = opts;
+  let repoId = "";
+  if (source === "official") {
+    repoId = "blefnk/awesome-cursor-rules";
+  } else if (source === "community") {
+    repoId = "pontusab/directories";
+  } else {
+    throw new Error(
+      "Cannot use source='prompt' together with --get. Please specify `--source official` or `--source community`."
+    );
+  }
+  const allAvailable = await fetchRepoFiles(repoId);
+  if (allAvailable.length === 0) {
+    relinka("error", "No rule files found in repository");
+    return;
+  }
+  const userWantsAll = ruleNames.length === 1 && ruleNames[0] === "all";
+  let targetNames = [];
+  if (userWantsAll) {
+    targetNames = allAvailable.map((f) => f.baseNameNoExt);
+  } else {
+    targetNames = ruleNames.map((name) => removeExtension(name));
+  }
+  const selected = allAvailable.filter((item) => targetNames.includes(item.baseNameNoExt));
+  if (selected.length === 0) {
+    relinka("error", "No matching rule files found for your --get arguments");
+    return;
+  }
+  const downloadedFiles = await downloadSpecificFiles(repoId, selected);
+  if (downloadedFiles.length === 0) {
+    relinka("error", "No rule files downloaded");
+    return;
+  }
+  const [owner] = repoId.split("/");
+  if (!owner) {
+    relinka("error", `Invalid repository: ${repoId}`);
+    return;
+  }
+  await installRules(downloadedFiles, owner, cwd);
+  relinka("verbose", "Rules installation completed (no prompt).");
+}
+async function fetchRepoFiles(repoId) {
+  const repo = RULES_REPOS.find((r) => r.id === repoId);
+  if (!repo) {
+    relinka("error", `Repository not found in config: ${repoId}`);
+    return [];
+  }
+  const [owner, repoName] = repoId.split("/");
+  const branch = repo.branch || DEFAULT_BRANCH;
+  const apiUrl = `https://api.github.com/repos/${owner}/${repoName}/git/trees/${branch}?recursive=1`;
+  try {
+    const repoData = await ofetch(apiUrl, { retry: 3, retryDelay: 1e3 });
+    let matches = [];
+    if (repo.isCommunity) {
+      const comPath = repo.communityPath || "";
+      matches = repoData.tree.filter(
+        (item) => item.type === "blob" && item.path.endsWith(".ts") && item.path.startsWith(comPath) && !item.path.split("/").some((part) => part.startsWith("."))
+      );
+    } else {
+      matches = repoData.tree.filter(
+        (item) => item.type === "blob" && item.path.endsWith(".md") && item.path.toLowerCase() !== "readme.md" && !item.path.split("/").some((part) => part.startsWith("."))
+      );
+    }
+    return matches.map((file) => {
+      const bn = path.basename(file.path);
+      let baseNoExt = "";
+      if (repo.isCommunity) {
+        baseNoExt = path.basename(bn, ".ts");
+      } else {
+        baseNoExt = path.basename(bn, ".md");
+      }
+      return {
+        path: file.path,
+        baseName: bn,
+        baseNameNoExt: baseNoExt,
+        isCommunity: !!repo.isCommunity
+      };
+    });
+  } catch (error) {
+    relinka("error", `Failed to fetch repo files from ${repoId}: ${error}`);
+    return [];
+  }
+}
+function removeExtension(name) {
+  const exts = [".ts", ".md", ".mdc"];
+  let result = name;
+  for (const ext of exts) {
+    if (result.toLowerCase().endsWith(ext)) {
+      result = result.slice(0, -ext.length);
+      break;
+    }
+  }
+  return result;
+}
+async function downloadSpecificFiles(repoId, files) {
+  const [owner, repoName] = repoId.split("/");
+  if (!owner || !repoName) {
+    relinka("error", "Invalid repository ID format");
+    return [];
+  }
+  const repo = RULES_REPOS.find((r) => r.id === repoId);
+  if (!repo) {
+    relinka("error", "Repository not found in configuration");
+    return [];
+  }
+  const branch = repo.branch || DEFAULT_BRANCH;
+  const repoCacheDir = getRepoCacheDir(owner);
+  await ensuredir(repoCacheDir);
+  const results = [];
+  for (const fileInfo of files) {
+    let expectedCacheFile = "";
+    if (fileInfo.isCommunity) {
+      expectedCacheFile = `${fileInfo.baseNameNoExt}${RULE_FILE_EXTENSION}`;
+    } else {
+      expectedCacheFile = `${fileInfo.baseNameNoExt}${RULE_FILE_EXTENSION}`;
+    }
+    const cacheFilePath = path.join(repoCacheDir, expectedCacheFile);
+    if (await fs.pathExists(cacheFilePath)) {
+      relinka("verbose", `[Cached] ${fileInfo.path} is already in cache.`);
+      results.push(expectedCacheFile);
+      continue;
+    }
+    try {
+      const contentUrl = `https://raw.githubusercontent.com/${owner}/${repoName}/${branch}/${fileInfo.path}`;
+      const content = await ofetch(contentUrl, {
+        responseType: "json",
+        retry: 2,
+        retryDelay: 500
+      });
+      if (fileInfo.isCommunity) {
+        const mdContent = convertTsToMdc(content, fileInfo.path);
+        await fs.writeFile(cacheFilePath, mdContent);
+      } else {
+        await fs.writeFile(cacheFilePath, content);
+      }
+      results.push(expectedCacheFile);
+      relinka("verbose", `Downloaded & processed ${fileInfo.path}`);
+    } catch (error) {
+      relinka("error", `Failed to download ${fileInfo.path}: ${error}`);
+    }
+  }
+  if (results.length > 0) {
+    const metadata = {
+      repoId,
+      branch,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalFiles: results.length,
+      tags: repo.tags || [],
+      isOfficial: repo.isOfficial || false,
+      isCommunity: repo.isCommunity || false
+    };
+    await fs.writeFile(
+      path.join(repoCacheDir, ".metadata.json"),
+      JSON.stringify(metadata, null, 2)
+    );
+    await fs.writeFile(path.join(repoCacheDir, ".last_updated"), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  return results;
+}
+export async function showRulesMenu({
+  cwd,
+  isDev,
+  source
+}) {
+  if (source === "official" || source === "community") {
+    const repoId = source === "official" ? "blefnk/awesome-cursor-rules" : "pontusab/directories";
+    const [owner] = repoId.split("/");
+    if (!owner) {
+      relinka("error", "Invalid repository selection");
+      return;
+    }
+    const filesToInstall = await downloadRules(repoId, isDev);
+    if (filesToInstall.length === 0) {
+      relinka("error", "No rule files found");
+      return;
+    }
+    await installRules(filesToInstall, owner, cwd);
+    relinka("verbose", "Rules installation completed");
+    return;
+  }
+  const hasInstalledMdc = await hasInstalledRules(cwd);
+  const mainOptions = ["download-official", "download-community"];
+  if (hasInstalledMdc) {
+    mainOptions.push("update", "manage");
+  }
+  const mainOption = await selectPrompt({
+    title: "AI IDE Rules",
+    options: [
+      {
+        value: "download-official",
+        label: "Download official",
+        hint: "blefnk/awesome-cursor-rules"
+      },
+      {
+        value: "download-community",
+        label: "Download community",
+        hint: "pontusab/directories"
+      },
+      ...hasInstalledMdc ? [
+        {
+          value: "update",
+          label: "Update rules",
+          hint: "Check and update installed rules"
+        },
+        {
+          value: "manage",
+          label: "Manage installed rules",
+          hint: "View or remove installed rules"
+        }
+      ] : []
+    ]
+  });
+  if (mainOption === "download-official" || mainOption === "download-community") {
+    const repoId = mainOption === "download-official" ? "blefnk/awesome-cursor-rules" : "pontusab/directories";
+    const [owner] = repoId.split("/");
+    if (!owner) {
+      relinka("error", "Invalid repository selection");
+      return;
+    }
+    const filesToInstall = await downloadRules(repoId, isDev);
+    if (filesToInstall.length === 0) {
+      relinka("error", "No rule files found");
+      return;
+    }
+    await installRules(filesToInstall, owner, cwd);
+    relinka("verbose", "Rules installation completed");
+  } else if (mainOption === "update") {
+    await handleRuleUpdates(cwd, isDev);
+  } else if (mainOption === "manage") {
+    const rulesDir = path.join(cwd, ".cursor", "rules");
+    const files = await fs.readdir(rulesDir);
+    const ruleFiles = files.filter(
+      (file) => file.endsWith(".md") || file.endsWith(RULE_FILE_EXTENSION)
+    );
+    if (ruleFiles.length === 0) {
+      relinka("info", "No rules installed");
+      return;
+    }
+    const managementOption = await selectPrompt({
+      title: "Rule Management",
+      options: [
+        {
+          value: "view",
+          label: "View installed rules",
+          hint: `${ruleFiles.length} rules installed`
+        },
+        {
+          value: "delete",
+          label: "Delete rules",
+          hint: "Remove installed rules"
+        }
+      ]
+    });
+    if (managementOption === "view") {
+      relinka("success", "Installed rules:");
+      for (const file of ruleFiles) {
+        relinka("info", `  - ${path.basename(file)}`);
+      }
+    } else if (managementOption === "delete") {
+      const filesToDelete = await multiselectPrompt({
+        title: "Select rules to delete",
+        displayInstructions: true,
+        options: ruleFiles.map((file) => ({
+          value: file,
+          label: path.basename(file)
+        }))
+      });
+      if (filesToDelete.length > 0) {
+        const confirmed = await confirmPrompt({
+          title: `Delete ${filesToDelete.length} rule(s)?`
+        });
+        if (confirmed) {
+          for (const file of filesToDelete) {
+            await fs.remove(path.join(rulesDir, file));
+          }
+          relinka("success", `Deleted ${filesToDelete.length} rule(s)`);
+        }
+      }
+    }
+  }
+}

package/bin/app/add/add-rule/add-rule-mod.d.ts

@@ -0,0 +1,19 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+        required: false;
+        default: false;
+    };
+    source: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    get: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+export default _default;

package/bin/app/add/add-rule/add-rule-mod.js

@@ -0,0 +1,55 @@
+import path from "@reliverse/pathkit";
+import { ensuredir } from "@reliverse/relifso";
+import { defineCommand } from "@reliverse/rempts";
+import os from "os";
+import { handleDirectRules, showRulesMenu } from "./add-rule-impl.js";
+export default defineCommand({
+  meta: {
+    name: "rule",
+    description: "Download and manage AI IDE rules"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run in development mode",
+      required: false,
+      default: false
+    },
+    source: {
+      type: "string",
+      description: "Source of the rules | Accepted: `official`, `community`, `prompt`",
+      default: "prompt"
+    },
+    get: {
+      type: "string",
+      // TODO: support array
+      description: "Specify rule files by name or pass `all` to install everything without prompt",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const { dev: isDev, source, get } = args;
+    const effectiveGet = get ? [get] : [];
+    if (source !== "prompt" && source !== "official" && source !== "community") {
+      throw new Error("Invalid source. Accepted values: `prompt`, `official`, `community`");
+    }
+    const homeDir = os.homedir();
+    const rulesBaseDir = path.join(homeDir, ".reliverse", "rules");
+    await ensuredir(rulesBaseDir);
+    if (effectiveGet && effectiveGet.length > 0) {
+      await handleDirectRules({
+        cwd: process.cwd(),
+        isDev,
+        source,
+        ruleNames: effectiveGet
+      });
+    } else {
+      await showRulesMenu({
+        cwd: process.cwd(),
+        isDev,
+        source
+      });
+    }
+    process.exit(0);
+  }
+});

package/bin/app/add/add-rule/add-rule-types.d.ts

@@ -0,0 +1,18 @@
+export interface UnghRepoResponse {
+    repo?: {
+        pushedAt: string;
+    };
+}
+export interface RuleRepo {
+    id: string;
+    author: string;
+    name: string;
+    description: string;
+    branch?: string;
+    tags?: string[];
+    category?: string;
+    website?: string;
+    isOfficial?: boolean;
+    isCommunity?: boolean;
+    communityPath?: string;
+}

package/bin/app/add/add-rule/add-rule-utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Converts a TypeScript rule file to markdown content (.mdc).
+ * It removes redundant declarations, import statements, and unwanted blocks.
+ *
+ * @param content - The raw TypeScript file content.
+ * @param filePath - The source file path.
+ * @returns The converted markdown content.
+ */
+export declare function convertTsToMdc(content: string, filePath: string): string;
+/**
+ * Checks if the Cursor rules directory exists in the given working directory.
+ * @param cwd - Current working directory.
+ * @returns Boolean indicating if the directory exists.
+ */
+export declare function hasCursorRulesDir(cwd: string): Promise<boolean>;
+/**
+ * Checks if at least one installed .mdc rule file exists in the .cursor/rules folder.
+ * @param cwd - Current working directory.
+ * @returns Boolean indicating if at least one .mdc file exists.
+ */
+export declare function hasInstalledRules(cwd: string): Promise<boolean>;
+/**
+ * Checks if updates are available for a given rule repository.
+ * @param repoId - Repository ID in format "owner/repo".
+ * @returns Boolean indicating if an update is available.
+ */
+export declare function checkRulesRepoUpdate(repoId: string): Promise<boolean>;
+/**
+ * Checks for updates only for rule repositories that are installed (i.e. their cache exists).
+ * @param isDev - Flag indicating development mode.
+ * @returns Boolean indicating if any updates are available.
+ */
+export declare function checkForRuleUpdates(isDev: boolean): Promise<boolean>;
+/**
+ * Downloads rules from a repository.
+ * Presents a multiselect prompt with all available rule files. Files that already exist
+ * in the cache will be labeled with a "(cached)" hint and will simply be reused.
+ * Files not cached will be downloaded (and converted if needed) and then saved.
+ *
+ * @param repoId - Repository identifier ("owner/repoName").
+ * @param isDev - Flag indicating development mode.
+ * @returns Array of file names (cached filenames) that will be installed.
+ */
+export declare function downloadRules(repoId: string, isDev: boolean): Promise<string[]>;
+/**
+ * Installs selected rules into the Cursor rules directory.
+ * Copies the cached files (with .mdc extension) into .cursor/rules,
+ * automatically overwriting any existing file.
+ *
+ * @param files - Array of cached file names to install.
+ * @param owner - Repository owner.
+ * @param cwd - Current working directory.
+ */
+export declare function installRules(files: string[], owner: string, cwd: string): Promise<void>;
+/**
+ * Handles rule updates by checking, downloading, and installing updates.
+ * Only processes repositories that are installed (where the cache directory exists).
+ * @param cwd - Current working directory.
+ * @param isDev - Flag indicating development mode.
+ */
+export declare function handleRuleUpdates(cwd: string, isDev: boolean): Promise<void>;