@reliverse/dler 1.7.91 → 1.7.93

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

@@ -0,0 +1,310 @@
+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, MAX_TOKENS, 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}` }
+    ],
+    maxTokens: MAX_TOKENS
+  });
+  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/app/ai/ai-menu.d.ts

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

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

@@ -0,0 +1,40 @@
+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/app/ai/cmd.d.ts

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

package/bin/app/ai/cmd.js

@@ -0,0 +1,63 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { ensureOpenAIKey } from "./ai-impl/ai-auth.js";
+import { AGENT_NAMES } from "./ai-impl/ai-const.js";
+import { aiAgenticTool } from "./ai-impl/ai-tools.js";
+import { aiMenu } from "./ai-menu.js";
+import { getRseConfigPath } from "../config/cfg-path.js";
+import { readRseConfig } from "../config/cfg-read.js";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+export default defineCommand({
+  meta: {
+    name: "ai",
+    description: "Chat with rse use rse Agent"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode"
+    },
+    generate: {
+      type: "string",
+      description: "Generate a new project"
+    },
+    agent: {
+      type: "string",
+      description: "Select a rse"
+    },
+    target: {
+      type: "string",
+      description: "Path to the file or directory (skips Relinter's prompt)"
+    }
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    if (isDev) {
+      relinka("verbose", "Using dev mode");
+    }
+    const cwd = getCurrentWorkingDirectory();
+    const { configPath } = await getRseConfigPath(cwd, isDev, false);
+    const config = await readRseConfig(configPath, isDev);
+    if (!config) {
+      throw new Error("Failed to read rse config");
+    }
+    const memory = await getOrCreateReliverseMemory();
+    await ensureOpenAIKey(memory);
+    const agent = args.agent;
+    if (agent !== void 0) {
+      if (!AGENT_NAMES.includes(agent)) {
+        throw new Error(`Invalid agent specified. Valid agents: ${AGENT_NAMES.join(", ")}`);
+      }
+      await aiAgenticTool({
+        config,
+        agent,
+        isKeyEnsured: true,
+        target: args.target
+      });
+      process.exit(0);
+    }
+    await aiMenu(config, true);
+    process.exit(0);
+  }
+});

package/bin/app/better/auth/(generators)/auth-config.d.ts

@@ -0,0 +1,44 @@
+import { type spinner as clackSpinner } from "@reliverse/rempts";
+import type { SupportedDatabases, SupportedPlugin } from "../init/cmd.js";
+export interface Import {
+    path: string;
+    variables: {
+        asType?: boolean;
+        name: string;
+        as?: string;
+    }[] | {
+        asType?: boolean;
+        name: string;
+        as?: string;
+    };
+}
+type Format = (code: string) => Promise<string>;
+interface CommonIndexConfig_Regex<AdditionalFields> {
+    type: "regex";
+    regex: RegExp;
+    getIndex: (args: {
+        matchIndex: number;
+        match: RegExpMatchArray;
+        additionalFields: AdditionalFields;
+    }) => number | null;
+}
+interface CommonIndexConfig_manual<AdditionalFields> {
+    type: "manual";
+    getIndex: (args: {
+        content: string;
+        additionalFields: AdditionalFields;
+    }) => number | null;
+}
+export type CommonIndexConfig<AdditionalFields> = CommonIndexConfig_Regex<AdditionalFields> | CommonIndexConfig_manual<AdditionalFields>;
+export declare function generateAuthConfig({ format, current_user_config, spinner, plugins, database, }: {
+    format: Format;
+    current_user_config: string;
+    spinner: ReturnType<typeof clackSpinner>;
+    plugins: SupportedPlugin[];
+    database: SupportedDatabases | null;
+}): Promise<{
+    generatedCode: string;
+    dependencies: string[];
+    envs: string[];
+}>;
+export {};