@reliverse/dler 1.7.92 → 1.7.94

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

@@ -0,0 +1,164 @@
+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/app/ai/ai-impl/gen/image.d.ts

@@ -0,0 +1,29 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    prompt: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    model: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    provider: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    size: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    quality: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;

package/bin/app/ai/ai-impl/gen/image.js

@@ -0,0 +1,77 @@
+import { openai } from "@ai-sdk/openai";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { experimental_generateImage as generateImage } from "ai";
+import { Buffer } from "buffer";
+import ora from "ora";
+import { uploadToProvider } from "../../../upload/providers/providers-mod.js";
+export default defineCommand({
+  meta: {
+    name: "generate",
+    description: "AI Image Generation & Upload"
+  },
+  args: {
+    prompt: {
+      type: "positional",
+      description: "Image generation prompt",
+      required: true
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "AI model (e.g., dall-e-3)",
+      default: "dall-e-3"
+    },
+    provider: {
+      type: "string",
+      alias: "p",
+      description: "Which provider to use for upload"
+    },
+    size: {
+      type: "string",
+      description: "Image dimensions (e.g. 1024x1024)",
+      default: "1024x1024"
+    },
+    quality: {
+      type: "string",
+      description: "Image quality (standard/hd)",
+      default: "standard"
+    }
+  },
+  run: async ({ args }) => {
+    const spinner = ora(`Generating image with prompt: "${args.prompt}"`).start();
+    try {
+      const { image } = await generateImage({
+        model: openai.image(args.model),
+        prompt: args.prompt,
+        providerOptions: {
+          openai: {
+            size: args.size,
+            quality: args.quality
+          }
+        }
+      });
+      spinner.text = "Uploading generated image...";
+      const buffer = Buffer.from(image.uint8Array);
+      const filename = `ai-gen-${Date.now()}.png`;
+      const [result] = await uploadToProvider(
+        [{ name: filename, data: buffer, type: "image/png" }],
+        args.provider
+      );
+      if (!result) {
+        throw new Error("Failed to upload image: No result returned");
+      }
+      spinner.succeed("Generation & upload complete!");
+      relinka("info", "\nGenerated Image Results:");
+      relinka("info", `File: ${result.name}`);
+      relinka("info", `URL: ${result.url}`);
+      if ("key" in result && result.key) relinka("info", `Key: ${result.key}`);
+      if ("uuid" in result && result.uuid) relinka("info", `UUID: ${result.uuid}
+`);
+    } catch (error) {
+      spinner.fail("Image generation failed");
+      relinka("error", String(error));
+      process.exit(1);
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+/**
+ * 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/app/ai/ai-impl/mcp/mcp-mod.js

@@ -0,0 +1,127 @@
+import { relinka } from "@reliverse/relinka";
+import dotenv from "dotenv";
+import { ofetch } from "ofetch";
+dotenv.config();
+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/app/ai/ai-impl/relinter/relinter.d.ts

@@ -0,0 +1,27 @@
+import type { RseConfig } from "../../../types/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: RseConfig, 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>;