@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/ai/ai-impl/code/code-mod.js

@@ -1,164 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, inputPrompt } from "@reliverse/rempts";
-import { generateText } from "ai";
-import { execaCommand } from "execa";
-import { glob } from "tinyglobby";
-import { MODEL } from "../ai-const.js";
-async function getUserPrompt() {
-  const response = await inputPrompt({
-    title: "AI Code Generation",
-    content: "Describe the code you want to generate:"
-  });
-  return response;
-}
-async function generateAiContent(userDescription) {
-  const result = await generateText({
-    model: MODEL,
-    system: `ALWAYS follow these rules:
-1. First line must be filepath comment: "// {filepath}"
-2. Use absolute paths from project root
-3. For modifications, include original code context
-4. Support TS, JS, JSON and MD formats
-5. Add TypeScript types where possible
-6. Use "~/" paths relative from "src"
-7. Prefer async/await over sync
-8. Your name is rse AI`,
-    prompt: userDescription
-  });
-  return { text: result.text };
-}
-function parseAiOutput(aiText) {
-  const [pathLine = "", ...codeLines] = aiText.split("\n");
-  const filePath = pathLine.replace(/^\/\/\s*/, "").trim();
-  const codeContent = codeLines.join("\n");
-  return { filePath, codeContent };
-}
-async function isFileModified(filePath) {
-  try {
-    const status = (await execaCommand(`git status --porcelain ${filePath}`)).stdout;
-    return status.trim().startsWith("M");
-  } catch {
-    return false;
-  }
-}
-async function confirmOverwrite(filePath) {
-  const modified = await isFileModified(filePath);
-  if (!modified) {
-    return true;
-  }
-  const confirmed = await confirmPrompt({
-    title: "Git Modification Warning",
-    content: `File ${path.basename(filePath)} has uncommitted changes. Overwrite?`,
-    defaultValue: false
-  });
-  return confirmed;
-}
-async function writeFileSafe(filePath, content) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
-  const dir = path.dirname(absolutePath);
-  if (!await fs.pathExists(dir)) {
-    await fs.mkdir(dir, { recursive: true });
-  }
-  await fs.writeFile(absolutePath, content, { flag: "wx" });
-}
-async function maybeFormatFile(filePath) {
-  const doFormat = await confirmPrompt({
-    title: "Code Formatting",
-    content: `Would you like to format ${path.basename(filePath)} with Biome?`,
-    defaultValue: false
-  });
-  if (!doFormat) {
-    return;
-  }
-  await execaCommand(`bun x biome check --write "${filePath}"`, {
-    stdio: "inherit"
-  });
-}
-async function maybeCommitFile(filePath) {
-  const shouldCommit = await confirmPrompt({
-    title: "Git Commit",
-    content: "Do you want to commit these changes?",
-    defaultValue: false
-  });
-  if (!shouldCommit) {
-    return;
-  }
-  const commitMessage = await inputPrompt({
-    title: "Commit Message",
-    content: "Enter a commit message:"
-  });
-  await commitChanges(filePath, { commitMessage });
-}
-async function commitChanges(filePath, options) {
-  await execaCommand(`git add ${filePath}`, { stdio: "inherit" });
-  await execaCommand(`git commit -m "${options.commitMessage}"`, {
-    stdio: "inherit"
-  });
-}
-export async function aiCodeCommand(fileOrFolderPatterns = [], notifyPerFile = false) {
-  const userPrompt = await getUserPrompt();
-  const { text: aiText } = await generateAiContent(userPrompt);
-  const { filePath, codeContent } = parseAiOutput(aiText);
-  if (!filePath) {
-    throw new Error("AI failed to provide valid file path");
-  }
-  const canOverwrite = await confirmOverwrite(filePath);
-  if (!canOverwrite) {
-    relinka("info", "Operation cancelled");
-    process.exit(0);
-  }
-  let fileExists = false;
-  if (await fs.pathExists(filePath)) {
-    fileExists = true;
-    await fs.rm(filePath);
-  }
-  await writeFileSafe(filePath, codeContent);
-  await maybeFormatFile(filePath);
-  await maybeCommitFile(filePath);
-  relinka("info", `Successfully ${fileExists ? "updated" : "created"} ${filePath}`);
-  if (!fileOrFolderPatterns.length) {
-    return;
-  }
-  const matchedPaths = await glob(fileOrFolderPatterns, { absolute: false });
-  if (!matchedPaths.length) {
-    relinka("info", "No files matched the given patterns.");
-    return;
-  }
-  if (!notifyPerFile) {
-    let anyModified = false;
-    for (const p of matchedPaths) {
-      if (await isFileModified(p)) {
-        anyModified = true;
-        break;
-      }
-    }
-    if (anyModified) {
-      const confirmAll = await confirmPrompt({
-        title: "Git Modification Warning",
-        content: "One or more matched files are modified. Continue anyway?",
-        defaultValue: false
-      });
-      if (!confirmAll) {
-        relinka("info", "Operation cancelled for matched files.");
-        return;
-      }
-    }
-  } else {
-    for (const p of matchedPaths) {
-      const modified = await isFileModified(p);
-      if (modified) {
-        const confirmThis = await confirmPrompt({
-          title: "Git Modification Warning",
-          content: `File ${path.basename(p)} has uncommitted changes. Continue anyway?`,
-          defaultValue: false
-        });
-        if (!confirmThis) {
-          relinka("info", `Operation cancelled for ${p}.`);
-        }
-      }
-    }
-  }
-  relinka("info", "Matched files processed successfully.");
-}

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

@@ -1,5 +0,0 @@
-/**
- * Handles "rse mcp" commands, supporting actions like listing servers,
- * retrieving server details, attributes, or instances.
- */
-export declare function handleMcpCommand(args: string[]): Promise<void>;

package/bin/impl/ai/ai-impl/mcp/mcp-mod.js

@@ -1,125 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { ofetch } from "ofetch";
-export async function handleMcpCommand(args) {
-  const subcommand = args[0]?.toLowerCase();
-  switch (subcommand) {
-    case "servers":
-      await listServers(args.slice(1));
-      break;
-    case "server":
-      await showServer(args.slice(1));
-      break;
-    case "attributes":
-      await listAttributes();
-      break;
-    case "instances":
-      await listInstances(args.slice(1));
-      break;
-    default:
-      printMcpUsage();
-      break;
-  }
-}
-async function listServers(flags) {
-  const params = parseFlags(flags);
-  const queryParams = {};
-  if (params.query) {
-    queryParams.query = params.query;
-  }
-  if (params.first) {
-    queryParams.first = params.first;
-  }
-  if (params.after) {
-    queryParams.after = params.after;
-  }
-  const baseUrl = "https://glama.ai/api/mcp/v1/servers";
-  const queryString = new URLSearchParams(queryParams).toString();
-  const url = queryString ? `${baseUrl}?${queryString}` : baseUrl;
-  try {
-    const data = await ofetch(url, { method: "GET" });
-    relinka("info", JSON.stringify(data, null, 2));
-  } catch (error) {
-    relinka("error", "Failed to list MCP servers:", String(error));
-  }
-}
-async function showServer(flags) {
-  const id = flags[0];
-  if (!id) {
-    relinka("error", "Missing server ID.");
-    return;
-  }
-  const baseUrl = "https://glama.ai/api/mcp/v1/servers";
-  const url = `${baseUrl}/${id}`;
-  try {
-    const data = await ofetch(url, { method: "GET" });
-    relinka("info", JSON.stringify(data, null, 2));
-  } catch (error) {
-    relinka("error", `Failed to retrieve server ${id}:`, String(error));
-  }
-}
-async function listAttributes() {
-  const url = "https://glama.ai/api/mcp/v1/attributes";
-  try {
-    const data = await ofetch(url, { method: "GET" });
-    relinka("info", JSON.stringify(data, null, 2));
-  } catch (error) {
-    relinka("error", "Failed to list MCP attributes:", String(error));
-  }
-}
-async function listInstances(flags) {
-  const params = parseFlags(flags);
-  const token = params.token || process.env.MCP_BEARER_TOKEN;
-  if (!token) {
-    relinka(
-      "error",
-      "Missing Bearer token. Use --token <YOUR_TOKEN> or set MCP_BEARER_TOKEN in env."
-    );
-    return;
-  }
-  const url = "https://glama.ai/api/mcp/v1/instances";
-  try {
-    const data = await ofetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    relinka("info", JSON.stringify(data, null, 2));
-  } catch (error) {
-    relinka("error", "Failed to list MCP instances:", String(error));
-  }
-}
-function parseFlags(flags) {
-  const result = {};
-  for (let i = 0; i < flags.length; i++) {
-    const flag = flags[i];
-    if (flag.startsWith("--")) {
-      const key = flag.replace(/^--/, "");
-      const next = flags[i + 1];
-      if (next && !next.startsWith("--")) {
-        result[key] = next;
-        i++;
-      } else {
-        result[key] = "true";
-      }
-    }
-  }
-  return result;
-}
-function printMcpUsage() {
-  relinka(
-    "info",
-    `Usage:
-  rse mcp servers [--query <text>] [--first <n>] [--after <cursor>]
-  rse mcp server <id>
-  rse mcp attributes
-  rse mcp instances [--token <YOUR_TOKEN_HERE>]
-Examples:
-  rse mcp servers --query "hacker news" --first 5
-  rse mcp server oge85xl22f
-  rse mcp attributes
-  rse mcp instances --token MY_SECRET_TOKEN
-  # or place MCP_BEARER_TOKEN=<TOKEN> in .env or the environment
-`
-  );
-}

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

@@ -1,27 +0,0 @@
-import type { ReliverseConfig } from "../../../schema/mod.js";
-/**
- * Describes a lint suggestion with file details and a recommended fix or note.
- */
-export interface LintSuggestion {
-    filePath: string;
-    startLine: number;
-    endLine: number;
-    suggestion: string;
-    severity: "error" | "warning" | "info";
-}
-/**
- * Coordinates the relinter process. Accepts multiple target paths.
- */
-export declare function agentRelinter(config: ReliverseConfig, targetPaths: string[], task?: string): Promise<void>;
-/**
- * Collects a list of recognized code files from a path.
- */
-export declare function collectLintableFiles(dirOrFile: string): Promise<string[]>;
-/**
- * Gathers lint suggestions for each file.
- */
-export declare function gatherLintSuggestions(files: string[], task?: string, promptDecision?: boolean): Promise<LintSuggestion[]>;
-/**
- * Persists lint suggestions to a JSON file.
- */
-export declare function writeSuggestionsToFile(suggestions: LintSuggestion[]): Promise<void>;

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

@@ -1,309 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt } from "@reliverse/rempts";
-import { generateText } from "ai";
-import { countTokens } from "gpt-tokenizer/model/gpt-4o-mini";
-import { CIRCULAR_TRIGGERS, MODEL, MODEL_NAME } from "../ai-const.js";
-function calculateTokens(content) {
-  return countTokens(content);
-}
-function calculatePrice(tokenCount) {
-  const costPerThousand = 0.15;
-  return tokenCount / 1e3 * costPerThousand;
-}
-export async function agentRelinter(config, targetPaths, task) {
-  try {
-    if (task && CIRCULAR_TRIGGERS.some((keyword) => task.toLowerCase().includes(keyword))) {
-      await handleCircularDependencies(targetPaths);
-      return;
-    }
-    const lintFiles = await collectAllLintableFiles(targetPaths);
-    if (lintFiles.length === 0) {
-      relinka("info", "No recognized code files found in the specified paths.");
-      return;
-    }
-    relinka("info", `Found ${lintFiles.length} file(s). Sending them to rse AI (${MODEL_NAME})...`);
-    let promptDecision;
-    const confirmDecision = config.relinterConfirm;
-    if (confirmDecision === "promptEachFile") {
-      promptDecision = true;
-    } else if (confirmDecision === "promptOnce") {
-      promptDecision = false;
-    }
-    const lintResults = await gatherLintSuggestions(lintFiles, task, promptDecision);
-    await writeSuggestionsToFile(lintResults);
-    relinka("info", "Lint suggestions written to relinter.json");
-  } catch (err) {
-    relinka("error", "Error:", err.message);
-    process.exit(1);
-  }
-}
-async function collectAllLintableFiles(pathsList) {
-  const fileSet = /* @__PURE__ */ new Set();
-  for (const rawPath of pathsList) {
-    const absolutePath = path.resolve(rawPath);
-    const files = await collectLintableFiles(absolutePath);
-    for (const f of files) {
-      fileSet.add(f);
-    }
-  }
-  return Array.from(fileSet);
-}
-export async function collectLintableFiles(dirOrFile) {
-  const stats = await fs.stat(dirOrFile);
-  if (stats.isFile()) {
-    return isCodeFile(dirOrFile) ? [dirOrFile] : [];
-  }
-  const entries = await fs.readdir(dirOrFile);
-  let results = [];
-  for (const entry of entries) {
-    const fullPath = path.join(dirOrFile, entry);
-    const entryStats = await fs.stat(fullPath);
-    if (entryStats.isDirectory()) {
-      results = results.concat(await collectLintableFiles(fullPath));
-    } else if (entryStats.isFile() && isCodeFile(fullPath)) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-function isCodeFile(filename) {
-  const recognizedExtensions = [
-    "js",
-    "jsx",
-    "ts",
-    "tsx",
-    "py",
-    "java",
-    "c",
-    "cpp",
-    "cc",
-    "hpp",
-    "cs",
-    "go",
-    "rs",
-    "php",
-    "rb",
-    "m",
-    "mm",
-    "scala",
-    "kt",
-    "kts",
-    "swift",
-    "dart",
-    "sh",
-    "bash",
-    "zsh",
-    "lua",
-    "el",
-    "ex",
-    "elm",
-    "clj",
-    "cljs",
-    "coffee",
-    "perl",
-    "pm",
-    "pl",
-    "groovy",
-    "gradle",
-    "sql",
-    "yml",
-    "yaml",
-    "toml",
-    "ini",
-    "config",
-    "json",
-    "jsonc",
-    "xml",
-    "html",
-    "css",
-    "scss",
-    "sass",
-    "dockerfile",
-    "makefile",
-    "cmake",
-    "asm",
-    "vue",
-    "svelte",
-    "pwn",
-    "inc"
-  ];
-  const ext = path.extname(filename).toLowerCase().replace(/^\./, "");
-  const base = path.basename(filename).toLowerCase();
-  return recognizedExtensions.includes(ext) || recognizedExtensions.includes(base);
-}
-export async function gatherLintSuggestions(files, task, promptDecision) {
-  const results = [];
-  for (const filePath of files) {
-    const code = await fs.readFile(filePath, "utf-8");
-    const fileChunks = chunkFile(code, 150);
-    for (const { content, offset } of fileChunks) {
-      const suggestions = await requestLintSuggestions(
-        filePath,
-        content,
-        offset,
-        task,
-        promptDecision
-      );
-      results.push(...suggestions);
-    }
-  }
-  return results;
-}
-function chunkFile(code, size) {
-  const lines = code.split("\n");
-  const chunks = [];
-  for (let i = 0; i < lines.length; i += size) {
-    const slice = lines.slice(i, i + size);
-    chunks.push({
-      content: slice.join("\n"),
-      offset: i
-    });
-  }
-  return chunks;
-}
-async function requestLintSuggestions(filePath, chunk, offset, task, promptDecision) {
-  let systemMessage = `
-You are an ESLint-like reviewer for all kinds of programming languages.
-Return valid JSON array only.
-Each item must have the following fields:
-- filePath (string)
-- startLine (number)
-- endLine (number)
-- suggestion (string)
-- severity (one of: "error", "warning", "info")
-Keep line numbers relative to the full file, offset is ${offset}.
-`;
-  if (task) {
-    systemMessage += `
-Additional instructions: ${task}
-`;
-  }
-  const combinedText = systemMessage + chunk;
-  const tokenCount = calculateTokens(combinedText);
-  const tokenCost = calculatePrice(tokenCount);
-  if (promptDecision === false) {
-    const confirmMsg = `Token usage for ${filePath} [offset ${offset}]: ${tokenCount} tokens (~$${tokenCost.toFixed(
-      4
-    )} USD)`;
-    const confirmed = await confirmPrompt({
-      title: "Confirm Token Usage",
-      content: confirmMsg
-    });
-    if (!confirmed) {
-      return [];
-    }
-  }
-  const response = await generateText({
-    model: MODEL,
-    messages: [
-      { role: "system", content: systemMessage },
-      { role: "user", content: `path: ${filePath}
-${chunk}` }
-    ]
-  });
-  let suggestions = [];
-  let text = response.text;
-  const codeFenceRegex = /```json\s*([\s\S]*?)\s*```/i;
-  const match = codeFenceRegex.exec(text);
-  if (match?.[1]) {
-    text = match[1].trim();
-  }
-  try {
-    const parsed = JSON.parse(text);
-    if (!Array.isArray(parsed)) {
-      throw new Error(`rse AI (${MODEL_NAME}) did not return an array.`);
-    }
-    parsed.forEach((s) => {
-      s.startLine += offset;
-      s.endLine += offset;
-      if (!s.severity || !["error", "warning", "info"].includes(s.severity)) {
-        s.severity = "warning";
-      }
-    });
-    suggestions = parsed;
-  } catch {
-    suggestions = [
-      {
-        filePath,
-        startLine: offset,
-        endLine: offset,
-        suggestion: `rse AI (${MODEL_NAME}) returned invalid JSON. Output:
-${response.text}`,
-        severity: "warning"
-      }
-    ];
-  }
-  return suggestions;
-}
-export async function writeSuggestionsToFile(suggestions) {
-  await fs.writeFile("relinter.json", JSON.stringify(suggestions, null, 2), "utf-8");
-}
-async function handleCircularDependencies(targetPaths) {
-  const lintFiles = await collectAllLintableFiles(targetPaths);
-  if (lintFiles.length === 0) {
-    relinka("info", "No recognized code files found in the specified paths.");
-    return;
-  }
-  const adjacency = {};
-  for (const filePath of lintFiles) {
-    adjacency[filePath] = [];
-    const code = await fs.readFile(filePath, "utf-8");
-    const importRegex = /import\s+(?:(?:[\w*\s{},]+)\s+from\s+)?["']([^"']+)["']/g;
-    let match;
-    while ((match = importRegex.exec(code)) !== null) {
-      const imported = match[1];
-      if (imported && (imported.startsWith("./") || imported.startsWith("../") || imported.startsWith("/"))) {
-        const resolvedImport = path.resolve(path.dirname(filePath), imported);
-        if (lintFiles.includes(resolvedImport)) {
-          adjacency[filePath].push(resolvedImport);
-        }
-      }
-    }
-  }
-  const visited = {};
-  const recStack = {};
-  const cycles = [];
-  const dfs = (node, pathStack) => {
-    visited[node] = true;
-    recStack[node] = true;
-    pathStack.push(node);
-    for (const neighbor of adjacency[node] ?? []) {
-      if (!visited[neighbor]) {
-        dfs(neighbor, pathStack);
-      } else if (recStack[neighbor]) {
-        const cycleStartIndex = pathStack.indexOf(neighbor);
-        const cycle = pathStack.slice(cycleStartIndex);
-        cycles.push([...cycle, neighbor]);
-      }
-    }
-    pathStack.pop();
-    recStack[node] = false;
-  };
-  for (const filePath of lintFiles) {
-    if (!visited[filePath]) {
-      dfs(filePath, []);
-    }
-  }
-  const suggestions = [];
-  if (cycles.length === 0) {
-    relinka("info", "No circular dependencies found.");
-  } else {
-    let i = 0;
-    for (const cycle of cycles) {
-      i++;
-      if (cycle[0]) {
-        suggestions.push({
-          filePath: cycle[0],
-          startLine: 0,
-          endLine: 0,
-          suggestion: `Detected circular dependency #${i}: ${cycle.join(" -> ")}`,
-          severity: "error"
-        });
-      }
-    }
-    relinka("error", `Detected ${cycles.length} circular dependency(ies).`);
-  }
-  await writeSuggestionsToFile(suggestions);
-}

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

@@ -1,3 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-import type { ReliverseMemory } from "../utils/schemaMemory.js";
-export declare function aiMenu(config: ReliverseConfig, isKeyEnsured: boolean, memory?: ReliverseMemory): Promise<void>;

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

@@ -1,40 +0,0 @@
-import { inputPrompt, selectPrompt } from "@reliverse/rempts";
-import { experimental } from "../utils/badgeNotifiers.js";
-import { ensureOpenAIKey } from "./ai-impl/ai-auth.js";
-import { aiChat } from "./ai-impl/ai-chat.js";
-import { agentRelinter } from "./ai-impl/relinter/relinter.js";
-const RANDOM_HINTS = [
-  "You can always exit by typing thing like 'bye', 'exit', or just by pressing Ctrl+C.",
-  "While chatting, use @relinter with paths to lint specific files or directories."
-];
-export async function aiMenu(config, isKeyEnsured, memory) {
-  if (!isKeyEnsured && memory === void 0) {
-    throw new Error("Memory is undefined");
-  }
-  if (!isKeyEnsured && memory !== void 0) {
-    await ensureOpenAIKey(memory);
-  }
-  const choice = await selectPrompt({
-    title: "rse AI",
-    content: `Random hint: ${RANDOM_HINTS[Math.floor(Math.random() * RANDOM_HINTS.length)]}`,
-    options: [
-      { label: "Talk to rse", value: "chat" },
-      {
-        label: "Use Relinter Agent",
-        value: "relinter",
-        hint: experimental
-      },
-      { label: "Exit", value: "exit" }
-    ]
-  });
-  if (choice === "chat") {
-    await aiChat(config);
-  } else if (choice === "relinter") {
-    const 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/auth/consts.d.ts

@@ -1,2 +0,0 @@
-export declare const configPath = "./src/lib/auth.ts";
-export declare const schemaPath = "./src/db/schema/user/tables.ts";

package/bin/impl/auth/consts.js

@@ -1,2 +0,0 @@
-export const configPath = "./src/lib/auth.ts";
-export const schemaPath = "./src/db/schema/user/tables.ts";