@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,324 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs, { ensuredir } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, multiselectPrompt } from "@reliverse/rempts";
-import { ofetch } from "ofetch";
-import pMap from "p-map";
-import { getMaxHeightSize } from "../../utils/microHelpers.js";
-import {
-  DEFAULT_BRANCH,
-  getRepoCacheDir,
-  RULE_FILE_EXTENSION,
-  RULES_REPOS
-} from "./add-rule-const.js";
-function cleanTsContent(content) {
-  content = content.replace(/^.*?content:\s*/s, "");
-  content = content.replace(/,\s*author:\s*\{[\s\S]*$/s, "");
-  return content.trim();
-}
-export function convertTsToMdc(content, filePath) {
-  let cleaned = content.replace(/export\s+const\s+\w+\s*=\s*/, "");
-  cleaned = cleaned.replace(/;\s*$/, "");
-  cleaned = cleaned.replace(/import\s+.*?from\s+['"].*?['"];?\s*/g, "");
-  cleaned = cleaned.replace(/export\s+default\s+/, "");
-  cleaned = cleaned.replace(/`/g, "");
-  cleaned = cleaned.trim();
-  cleaned = cleanTsContent(cleaned);
-  const frontmatter = [
-    "---",
-    `description: ${path.basename(filePath, ".ts")}`,
-    "glob: []",
-    "alwaysApply: false",
-    "---",
-    ""
-  ].join("\n");
-  return frontmatter + cleaned;
-}
-export async function hasCursorRulesDir(cwd) {
-  const rulesDir = path.join(cwd, ".cursor", "rules");
-  return fs.pathExists(rulesDir);
-}
-export async function hasInstalledRules(cwd) {
-  const rulesDir = path.join(cwd, ".cursor", "rules");
-  if (!await fs.pathExists(rulesDir)) return false;
-  const files = await fs.readdir(rulesDir);
-  return files.some((file) => file.endsWith(RULE_FILE_EXTENSION));
-}
-export async function checkRulesRepoUpdate(repoId) {
-  const [owner, repoName] = repoId.split("/");
-  if (!owner || !repoName) return false;
-  const repoCacheDir = getRepoCacheDir(owner);
-  const versionFilePath = path.join(repoCacheDir, ".last_updated");
-  if (!await fs.pathExists(repoCacheDir)) {
-    return true;
-  }
-  let currentDate = null;
-  if (await fs.pathExists(versionFilePath)) {
-    currentDate = await fs.readFile(versionFilePath, "utf-8");
-  } else {
-    return true;
-  }
-  try {
-    const url = `https://ungh.cc/repos/${owner}/${repoName}`;
-    const data = await ofetch(url);
-    const latestDate = data.repo?.pushedAt ?? null;
-    if (!latestDate) return false;
-    return new Date(currentDate) < new Date(latestDate);
-  } catch (error) {
-    console.error("Failed to check for updates:", error);
-    return false;
-  }
-}
-export async function checkForRuleUpdates(isDev) {
-  let hasUpdates = false;
-  for (const repo of RULES_REPOS) {
-    const [owner] = repo.id.split("/");
-    if (!owner) continue;
-    if (!await fs.pathExists(getRepoCacheDir(owner))) continue;
-    const hasRepoUpdate = await checkRulesRepoUpdate(repo.id);
-    if (hasRepoUpdate) {
-      hasUpdates = true;
-      if (isDev) {
-        relinka("info", `Updates available for ${repo.id}`);
-      }
-    }
-  }
-  return hasUpdates;
-}
-async function getCachedRuleFiles(owner) {
-  relinka("verbose", `Getting cached rule files for owner: ${owner}`);
-  const repoCacheDir = getRepoCacheDir(owner);
-  if (!await fs.pathExists(repoCacheDir)) {
-    relinka("verbose", `Cache directory does not exist: ${repoCacheDir}`);
-    return [];
-  }
-  try {
-    const files = await fs.readdir(repoCacheDir, { recursive: true });
-    const filteredFiles = files.filter(
-      (file) => typeof file === "string" && file.endsWith(RULE_FILE_EXTENSION) && !file.startsWith(".")
-    );
-    relinka(
-      "success",
-      `Found ${filteredFiles.length} rule files (${RULE_FILE_EXTENSION}) in cache`
-    );
-    return filteredFiles;
-  } catch (error) {
-    relinka("error", `Failed to read cached rules: ${error}`);
-    return [];
-  }
-}
-export async function downloadRules(repoId, isDev) {
-  relinka("verbose", `Development mode: ${isDev}`);
-  relinka("verbose", `Starting download process for repository: ${repoId}`);
-  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);
-  relinka("verbose", `Cache directory: ${repoCacheDir}`);
-  const apiUrl = `https://api.github.com/repos/${owner}/${repoName}/git/trees/${branch}?recursive=1`;
-  let availableFiles = [];
-  try {
-    const repoData = await ofetch(apiUrl, {
-      retry: 3,
-      retryDelay: 1e3,
-      onResponseError: (error) => {
-        if (error.response?.status === 404) {
-          throw new Error(`Repository or branch not found: ${repoId}#${branch}`);
-        }
-        if (error.response?.status === 403) {
-          throw new Error("GitHub API rate limit exceeded. Please try again later.");
-        }
-        throw new Error(
-          `Failed to fetch repository: ${error.response?.statusText || "Unknown error"}`
-        );
-      }
-    });
-    if (repo.isCommunity) {
-      const communityPath = repo.communityPath;
-      if (!communityPath) {
-        relinka("error", "Community path not defined for repository");
-        return [];
-      }
-      availableFiles = repoData.tree.filter(
-        (item) => item.type === "blob" && item.path.endsWith(".ts") && item.path.startsWith(communityPath) && !item.path.split("/").some((part) => part.startsWith("."))
-      );
-    } else {
-      availableFiles = repoData.tree.filter(
-        (item) => item.type === "blob" && item.path.endsWith(".md") && item.path.toLowerCase() !== "readme.md" && !item.path.split("/").some((part) => part.startsWith("."))
-      );
-    }
-    if (availableFiles.length === 0) {
-      relinka("error", "No rule files found in repository");
-      return [];
-    }
-    const maxItems = getMaxHeightSize();
-    const totalFiles = availableFiles.length;
-    availableFiles = availableFiles.slice(0, maxItems);
-    const cachedFiles = await getCachedRuleFiles(owner);
-    const options = availableFiles.map((file, index) => {
-      const baseName = path.basename(file.path);
-      let expectedCacheFile;
-      if (repo.isCommunity) {
-        expectedCacheFile = `${path.basename(file.path, ".ts")}${RULE_FILE_EXTENSION}`;
-      } else {
-        expectedCacheFile = `${path.basename(file.path, ".md")}${RULE_FILE_EXTENSION}`;
-      }
-      const isCached = cachedFiles.includes(expectedCacheFile);
-      return {
-        value: file.path,
-        label: `${index + 1}. ${baseName}`,
-        hint: isCached ? "cached" : void 0
-      };
-    });
-    const selectedFiles = await multiselectPrompt({
-      title: `Select rules to download from ${repoId} (${Math.min(
-        totalFiles,
-        maxItems
-      )} of ${totalFiles} available)`,
-      content: `If you don't see all rules, try increasing your terminal height (current: ${maxItems})`,
-      options
-    });
-    if (selectedFiles.length === 0) {
-      relinka("error", "No rules selected for download");
-      return [];
-    }
-    const downloadedFiles = [];
-    const total = selectedFiles.length;
-    await pMap(
-      selectedFiles,
-      async (filePath) => {
-        let expectedCacheFile;
-        if (repo.isCommunity) {
-          expectedCacheFile = `${path.basename(filePath, ".ts")}${RULE_FILE_EXTENSION}`;
-        } else {
-          expectedCacheFile = `${path.basename(filePath, ".md")}${RULE_FILE_EXTENSION}`;
-        }
-        const cacheFilePath = path.join(repoCacheDir, expectedCacheFile);
-        if (await fs.pathExists(cacheFilePath)) {
-          relinka("verbose", `[Cached] ${filePath} is already in cache.`);
-          downloadedFiles.push(expectedCacheFile);
-          return;
-        }
-        try {
-          const contentUrl = `https://raw.githubusercontent.com/${owner}/${repoName}/${branch}/${filePath}`;
-          const content = await ofetch(contentUrl, {
-            responseType: "text",
-            retry: 2,
-            retryDelay: 500
-          });
-          if (repo.isCommunity) {
-            const mdContent = convertTsToMdc(content, filePath);
-            await fs.writeFile(cacheFilePath, mdContent);
-          } else {
-            await fs.writeFile(cacheFilePath, content);
-          }
-          downloadedFiles.push(expectedCacheFile);
-          relinka("verbose", `[${downloadedFiles.length}/${total}] Processed ${filePath}`);
-        } catch (error) {
-          relinka("error", `Failed to process ${filePath}: ${error}`);
-        }
-      },
-      { concurrency: 5 }
-    );
-    if (downloadedFiles.length === 0) {
-      relinka("error", "Failed to download any rule files");
-      return [];
-    }
-    const metadata = {
-      repoId,
-      branch,
-      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      totalFiles: downloadedFiles.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());
-    relinka("verbose", `Processed ${downloadedFiles.length}/${total} rule file(s) successfully`);
-    return downloadedFiles;
-  } catch (error) {
-    relinka("error", `Failed to download rules: ${error}`);
-    return [];
-  }
-}
-export async function installRules(files, owner, cwd) {
-  relinka("verbose", `Installing ${files.length} rule(s) from owner: ${owner}`);
-  const repoCacheDir = getRepoCacheDir(owner);
-  const cursorRulesDir = path.join(cwd, ".cursor", "rules");
-  await ensuredir(cursorRulesDir);
-  relinka("verbose", `Source directory: ${repoCacheDir}`);
-  relinka("verbose", `Target directory: ${cursorRulesDir}`);
-  let installedCount = 0;
-  let skippedCount = 0;
-  for (const file of files) {
-    const sourceFile = path.join(repoCacheDir, file);
-    const baseFileName = path.basename(file, path.extname(file));
-    const targetFileName = `${baseFileName}${RULE_FILE_EXTENSION}`;
-    const targetFile = path.join(cursorRulesDir, targetFileName);
-    relinka("verbose", `Copying file: ${file} -> ${targetFile}`);
-    try {
-      await fs.copy(sourceFile, targetFile, { overwrite: true });
-      installedCount++;
-      relinka("success", `Installed ${targetFileName}`);
-    } catch (error) {
-      relinka("error", `Failed to install ${file}: ${error}`);
-      skippedCount++;
-    }
-  }
-  if (files.length > 5) {
-    relinka("success", `Installed ${installedCount} rule file(s)`);
-  }
-  if (skippedCount > 0) {
-    relinka("verbose", `Skipped ${skippedCount} rule file(s)`);
-  }
-  relinka("verbose", `Total installed: ${installedCount}, skipped: ${skippedCount}`);
-}
-export async function handleRuleUpdates(cwd, isDev) {
-  relinka("verbose", `Checking for rule updates in workspace: ${cwd}`);
-  const hasUpdates = await checkForRuleUpdates(isDev);
-  if (!hasUpdates) {
-    relinka("success", "No updates available for installed rules");
-    return;
-  }
-  relinka("verbose", "Updates available for installed rules");
-  const shouldUpdate = await confirmPrompt({
-    title: "Updates available for installed rules. Download now?"
-  });
-  if (!shouldUpdate) {
-    relinka("verbose", "User chose not to update rules");
-    return;
-  }
-  relinka("verbose", "Starting rule update process");
-  for (const repo of RULES_REPOS) {
-    const [owner] = repo.id.split("/");
-    if (!owner) continue;
-    if (!await fs.pathExists(getRepoCacheDir(owner))) continue;
-    relinka("info", `Updating rules for repository: ${repo.id}`);
-    const repoId = repo.id;
-    const hasRepoUpdate = await checkRulesRepoUpdate(repoId);
-    if (hasRepoUpdate) {
-      relinka("info", `Updates available for ${repoId}, downloading...`);
-      const files = await downloadRules(repoId, isDev);
-      if (files.length > 0 && await hasCursorRulesDir(cwd)) {
-        relinka("info", `Installing downloaded rules into ${cwd}/.cursor/rules`);
-        await installRules(files, owner, cwd);
-      }
-    } else {
-      relinka("info", `No updates available for ${repo.id}`);
-    }
-  }
-  relinka("success", "Rule updates completed");
-}

package/bin/impl/ai/ai-impl/ai-auth.d.ts

@@ -1,10 +0,0 @@
-import type { ReliverseMemory } from "../../utils/schemaMemory.js";
-/**
- * Ensures we have a valid OpenAI API key in either:
- *  1) process.env
- *  2) memory.openaiKey
- *
- * If not found or invalid, prompts the user to provide one,
- * then stores it in memory.
- */
-export declare function ensureOpenAIKey(memory: ReliverseMemory): Promise<string>;

package/bin/impl/ai/ai-impl/ai-auth.js

@@ -1,59 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { inputPrompt } from "@reliverse/rempts";
-import { ofetch } from "ofetch";
-import { updateReliverseMemory } from "../../utils/reliverseMemory.js";
-export async function ensureOpenAIKey(memory) {
-  let envKeyInvalid = false;
-  let memoryKeyInvalid = false;
-  if (process.env.OPENAI_API_KEY) {
-    try {
-      await ofetch("https://api.openai.com/v1/models", {
-        headers: {
-          Authorization: `Bearer ${process.env.OPENAI_API_KEY}`
-        }
-      });
-      return process.env.OPENAI_API_KEY;
-    } catch {
-      envKeyInvalid = true;
-      relinka("warn", "OpenAI key in .env file is invalid, let me check my memory...");
-    }
-  }
-  if (memory.openaiKey) {
-    try {
-      await ofetch("https://api.openai.com/v1/models", {
-        headers: { Authorization: `Bearer ${memory.openaiKey}` }
-      });
-      process.env.OPENAI_API_KEY = memory.openaiKey;
-      if (envKeyInvalid) {
-        relinka("info", "Found valid key in memory, using it instead of invalid .env key");
-      }
-      return memory.openaiKey;
-    } catch {
-      memoryKeyInvalid = true;
-      relinka("warn", "OpenAI key in memory is invalid");
-    }
-  }
-  if (envKeyInvalid || memoryKeyInvalid) {
-    relinka("info", "Please provide a new OpenAI API key as existing ones are invalid");
-  }
-  const token = await inputPrompt({
-    title: "Please enter your OpenAI API key.\n(It will be securely stored on your machine):",
-    content: "Get one at https://platform.openai.com/api-keys",
-    validate: async (value) => {
-      if (!value?.trim()) {
-        return "API key is required";
-      }
-      try {
-        await ofetch("https://api.openai.com/v1/models", {
-          headers: { Authorization: `Bearer ${value}` }
-        });
-        return true;
-      } catch {
-        return "Invalid API key. Please check your key and try again.";
-      }
-    }
-  });
-  await updateReliverseMemory({ openaiKey: token });
-  process.env.OPENAI_API_KEY = token;
-  return token;
-}

package/bin/impl/ai/ai-impl/ai-chat.d.ts

@@ -1,5 +0,0 @@
-import type { ReliverseConfig } from "../../schema/mod.js";
-/**
- * Initiates a loop to capture user input and provide AI responses.
- */
-export declare function aiChat(config: ReliverseConfig): Promise<void>;

package/bin/impl/ai/ai-impl/ai-chat.js

@@ -1,93 +0,0 @@
-import { re } from "@reliverse/relico";
-import { inputPrompt, msg } from "@reliverse/rempts";
-import { streamText } from "ai";
-import { EXIT_KEYWORDS, MODEL } from "./ai-const.js";
-import { agentRelinter } from "./relinter/relinter.js";
-const messages = [];
-export async function aiChat(config) {
-  while (true) {
-    const userInput = await getUserInput();
-    const parsedInput = parseUserInput(userInput);
-    if (parsedInput.hasRelinter) {
-      await handleRelinterFlow(config, parsedInput);
-    } else {
-      await handleNormalChatFlow(userInput);
-    }
-    if (shouldExit(userInput)) {
-      break;
-    }
-  }
-}
-async function getUserInput() {
-  const input = await inputPrompt({ title: "You:", symbol: "info" });
-  return input.trim();
-}
-function parseUserInput(userInput) {
-  const tokens = userInput.split(/\s+/);
-  let hasRelinter = false;
-  const paths = [];
-  const taskParts = [];
-  for (const rawToken of tokens) {
-    const token = removeTrailingPunctuation(rawToken);
-    if (token.toLowerCase() === "@relinter") {
-      hasRelinter = true;
-      continue;
-    }
-    if (looksLikePath(token)) {
-      paths.push(token);
-      continue;
-    }
-    taskParts.push(token);
-  }
-  return {
-    hasRelinter,
-    paths,
-    task: taskParts.join(" ").trim()
-  };
-}
-function removeTrailingPunctuation(token) {
-  return token.replace(/[.,!?;:]+$/, "");
-}
-function looksLikePath(token) {
-  return token.includes("/") || token.includes("\\") || /\.(jsx?|tsx?)$/i.test(token);
-}
-async function handleRelinterFlow(config, parsedInput) {
-  const { hasRelinter, paths, task } = parsedInput;
-  if (!hasRelinter) return;
-  const finalPaths = paths.length > 0 ? paths : ["."];
-  await agentRelinter(config, finalPaths, task);
-}
-async function handleNormalChatFlow(userInput) {
-  messages.push({ role: "user", content: userInput });
-  console.log(`${re.dim("\u2139")}  ${re.bold("rse")}`);
-  try {
-    const result = streamText({
-      model: MODEL,
-      messages,
-      system: "You are a professional software developer. Your name is rse"
-    });
-    let assistantResponse = "";
-    process.stdout.write(re.dim("\u2502  "));
-    for await (const delta of result.textStream) {
-      const lines = delta.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (i > 0) {
-          console.log();
-          process.stdout.write(re.dim("\u2502  "));
-        }
-        process.stdout.write(lines[i] ?? "");
-      }
-      assistantResponse += delta;
-    }
-    console.log();
-    msg({ type: "M_BAR" });
-    messages.push({ role: "assistant", content: assistantResponse });
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : String(error));
-    msg({ type: "M_BAR", borderColor: "dim" });
-  }
-}
-function shouldExit(userInput) {
-  const lower = userInput.toLowerCase();
-  return EXIT_KEYWORDS.some((keyword) => keyword === lower);
-}

package/bin/impl/ai/ai-impl/ai-const.d.ts

@@ -1,7 +0,0 @@
-import type { LanguageModel } from "ai";
-export declare const AGENT_NAMES: readonly ["relinter"];
-export declare const MODEL: LanguageModel;
-export declare const MODEL_NAME: string;
-export declare const MAX_TOKENS = 1000;
-export declare const CIRCULAR_TRIGGERS: string[];
-export declare const EXIT_KEYWORDS: string[];

package/bin/impl/ai/ai-impl/ai-const.js

@@ -1,14 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-export const AGENT_NAMES = ["relinter"];
-export const MODEL = openai("gpt-4o-mini");
-export const MODEL_NAME = MODEL.modelId;
-export const MAX_TOKENS = 1e3;
-export const CIRCULAR_TRIGGERS = [
-  "detect circular dependencies",
-  "verify circular dependencies",
-  "check circular dependencies",
-  "detect circular deps",
-  "verify circular deps",
-  "check circular deps"
-];
-export const EXIT_KEYWORDS = ["thanks! bye!", "goodbye", "quit", "exit", "bye", "gg"];

package/bin/impl/ai/ai-impl/ai-tools.d.ts

@@ -1,5 +0,0 @@
-import type { AIAgentOptions } from "./ai-types";
-/**
- * Invokes a specific agent based on provided options.
- */
-export declare function aiAgenticTool({ config, agent, isKeyEnsured, memory, target, }: AIAgentOptions): Promise<void>;

package/bin/impl/ai/ai-impl/ai-tools.js

@@ -1,32 +0,0 @@
-import { inputPrompt } from "@reliverse/rempts";
-import { ensureOpenAIKey } from "./ai-auth.js";
-import { AGENT_NAMES } from "./ai-const.js";
-import { agentRelinter } from "./relinter/relinter.js";
-export async function aiAgenticTool({
-  config,
-  agent,
-  isKeyEnsured,
-  memory,
-  target
-}) {
-  if (!AGENT_NAMES.includes(agent)) {
-    throw new Error("Invalid agent specified.");
-  }
-  if (!isKeyEnsured && memory === void 0) {
-    throw new Error("Memory is undefined");
-  }
-  if (!isKeyEnsured && memory !== void 0) {
-    await ensureOpenAIKey(memory);
-  }
-  if (agent === "relinter") {
-    let targetPath = target;
-    if (!targetPath) {
-      targetPath = await inputPrompt({
-        title: "Relinter",
-        content: "Enter the path to the file or directory to lint:"
-      });
-    }
-    const userPaths = targetPath.split(/\s+/).filter(Boolean);
-    await agentRelinter(config, userPaths);
-  }
-}

package/bin/impl/ai/ai-impl/ai-types.d.ts

@@ -1,12 +0,0 @@
-import type { ReliverseConfig } from "../../schema/mod.js";
-import type { ReliverseMemory } from "../../utils/schemaMemory.js";
-import type { AGENT_NAMES, CIRCULAR_TRIGGERS } from "./ai-const";
-export type CircularTrigger = (typeof CIRCULAR_TRIGGERS)[number];
-export type AiSdkAgent = (typeof AGENT_NAMES)[number];
-export interface AIAgentOptions {
-    config: ReliverseConfig;
-    agent: AiSdkAgent;
-    isKeyEnsured: boolean;
-    memory?: ReliverseMemory;
-    target?: string;
-}

package/bin/impl/ai/ai-impl/code/code-mod.d.ts

@@ -1,6 +0,0 @@
-/**
- * Main command entry.
- * @param fileOrFolderPatterns  Optional glob patterns to match existing files/folders
- * @param notifyPerFile         Notify about uncommitted changes per file (true) or only once (false)
- */
-export declare function aiCodeCommand(fileOrFolderPatterns?: string[], notifyPerFile?: boolean): Promise<void>;