@reliverse/dler 1.7.92 → 1.7.94

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

@@ -0,0 +1,324 @@
+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/app/add/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/add/cmd.js

@@ -0,0 +1,55 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { getOrCreateRseConfig } from "../config/cfg-core.js";
+import { showManualBuilderMenu } from "../init/init-utils/init-impl.js";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+export default defineCommand({
+  meta: {
+    name: "add",
+    description: "Create, customize, and integrate new or existing projects with rses"
+  },
+  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)"
+    }
+  },
+  subCommands: {
+    rule: () => import("./add-rule/add-rule-mod.js").then((r) => r.default)
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    if (isDev) {
+      relinka("verbose", "Using dev mode");
+    }
+    const cwd = getCurrentWorkingDirectory();
+    const { config } = await getOrCreateRseConfig({
+      projectPath: cwd,
+      isDev,
+      overrides: {}
+    });
+    const memory = await getOrCreateReliverseMemory();
+    await showManualBuilderMenu({
+      cwd,
+      isDev,
+      config,
+      memory,
+      projectName: "",
+      skipPrompts: false
+    });
+    process.exit(0);
+  }
+});

package/bin/app/agg/cmd.js

@@ -1,6 +1,6 @@
 import path from "@reliverse/pathkit";
-import { inputPrompt, defineArgs, defineCommand } from "@reliverse/rempts";
-import { useAggregator } from "../../libs/sdk/sdk-impl/utils/agg/agg-2.js";
+import { defineArgs, defineCommand, inputPrompt } from "@reliverse/rempts";
+import { useAggregator } from "../utils/agg/agg-2.js";
 export default defineCommand({
   args: defineArgs({
     imports: {

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

@@ -0,0 +1,10 @@
+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/app/ai/ai-impl/ai-auth.js

@@ -0,0 +1,61 @@
+import { relinka } from "@reliverse/relinka";
+import { inputPrompt } from "@reliverse/rempts";
+import dotenv from "dotenv";
+import { ofetch } from "ofetch";
+import { updateReliverseMemory } from "../../utils/reliverseMemory.js";
+dotenv.config();
+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/app/ai/ai-impl/ai-chat.d.ts

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

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

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

@@ -0,0 +1,7 @@
+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/app/ai/ai-impl/ai-const.js

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

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

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

@@ -0,0 +1,12 @@
+import type { RseConfig } from "../../types/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: RseConfig;
+    agent: AiSdkAgent;
+    isKeyEnsured: boolean;
+    memory?: ReliverseMemory;
+    target?: string;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * 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>;