@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/utils/projectRepository.js

@@ -0,0 +1,229 @@
+import path from "@reliverse/pathkit";
+import { re } from "@reliverse/relico";
+import fs, { ensuredir, setHiddenAttribute } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { Value } from "@sinclair/typebox/value";
+import { parseJSONC } from "confbox";
+import { ofetch } from "ofetch";
+import { cliHomeRepos } from "../config/constants.js";
+import { experimental, recommended } from "./badgeNotifiers.js";
+import {
+  DEFAULT_REPOS_CONFIG,
+  generateReposJsonSchema,
+  reposSchema,
+  shouldRegenerateSchema
+} from "./schemaTemplate.js";
+export const REPO_TEMPLATES = [
+  {
+    id: "blefnk/relivator-nextjs-template",
+    author: "blefnk",
+    name: "relivator",
+    description: "Full-featured e-commerce template with auth, payments, etc.",
+    category: "website"
+  },
+  {
+    id: "blefnk/next-react-ts-src-minimal",
+    author: "blefnk",
+    name: "next-react-ts-src-minimal",
+    description: "Essentials only: minimal Next.js with TypeScript template",
+    category: "website"
+  },
+  {
+    id: "blefnk/all-in-one-nextjs-template",
+    author: "blefnk",
+    name: "all-in-one-nextjs-template",
+    description: "Comprehensive Next.js eCommerce template with multiple features",
+    category: "website"
+  },
+  {
+    id: "blefnk/create-t3-app",
+    author: "blefnk",
+    name: "create-t3-app",
+    description: "Type-safe Next.js template with tRPC, Drizzle, and Tailwind",
+    category: "website"
+  },
+  {
+    id: "blefnk/create-next-app",
+    author: "blefnk",
+    name: "create-next-app",
+    description: "Basic Next.js starter template",
+    category: "website"
+  },
+  {
+    id: "blefnk/astro-starlight-template",
+    author: "blefnk",
+    name: "astro-starlight-template",
+    description: "Documentation site template using Astro and Starlight",
+    category: "website"
+  },
+  {
+    id: "blefnk/versator-nextjs-template",
+    author: "blefnk",
+    name: "versator",
+    description: "Versatile Next.js template for various use cases",
+    category: "website"
+  },
+  {
+    id: "microsoft/vscode-extension-samples",
+    author: "microsoft",
+    name: "vscode-extension-samples",
+    description: "Official VS Code extension samples",
+    category: "vscode"
+  },
+  {
+    id: "microsoft/vscode-extension-template",
+    author: "microsoft",
+    name: "vscode-extension-template",
+    description: "Basic VS Code extension template",
+    category: "vscode"
+  },
+  {
+    id: "reliverse/template-browser-extension",
+    author: "reliverse",
+    name: "template-browser-extension",
+    description: "Browser extension starter template",
+    category: "browser"
+  },
+  {
+    id: "blefnk/relivator-docker-template",
+    author: "blefnk",
+    name: "relivator-docker-template",
+    description: "Relivator template with Docker",
+    category: "website"
+  }
+];
+async function getReposConfigPath() {
+  await ensuredir(cliHomeRepos);
+  if (await shouldRegenerateSchema()) {
+    await generateReposJsonSchema();
+  }
+  return path.join(cliHomeRepos, "repos.json");
+}
+async function readReposConfig() {
+  const configPath = await getReposConfigPath();
+  if (!await fs.pathExists(configPath)) {
+    return DEFAULT_REPOS_CONFIG;
+  }
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const parsed = parseJSONC(content);
+    if (Value.Check(reposSchema, parsed)) {
+      return parsed;
+    }
+  } catch (error) {
+    relinka("warn", "Failed to parse repos.json:", String(error));
+  }
+  return DEFAULT_REPOS_CONFIG;
+}
+async function writeReposConfig(config) {
+  const configPath = await getReposConfigPath();
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+export async function getRepoInfo(repoId) {
+  const config = await readReposConfig();
+  return config.repos.find((t) => t.id === repoId) ?? null;
+}
+async function fetchRepoData(owner, name) {
+  const url = `https://ungh.cc/repos/${owner}/${name}`;
+  try {
+    const data = await ofetch(url);
+    return data.repo;
+  } catch (error) {
+    relinka("warn", "Failed to fetch repo info from ungh:", String(error));
+    return null;
+  }
+}
+export async function saveRepoToDevice(repo, projectPath) {
+  try {
+    const repoSavePath = path.join(cliHomeRepos, repo.author, repo.name);
+    await ensuredir(path.dirname(repoSavePath));
+    await fs.copy(projectPath, repoSavePath);
+    const gitFolderPath = path.join(repoSavePath, ".git");
+    await setHiddenAttribute(gitFolderPath);
+    const [owner, repoName] = repo.id.split("/");
+    if (!owner || !repoName) {
+      throw new Error(`Invalid repo ID format: ${repo.id}`);
+    }
+    const repoData = await fetchRepoData(owner, repoName);
+    const repoInfo = {
+      id: repo.id,
+      author: repo.author,
+      name: repo.name,
+      description: repo.description,
+      category: repo.category,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      localPath: repoSavePath,
+      github: repoData ? {
+        stars: repoData.stars,
+        forks: repoData.forks,
+        watchers: repoData.watchers,
+        createdAt: repoData.createdAt,
+        updatedAt: repoData.updatedAt,
+        pushedAt: repoData.pushedAt,
+        defaultBranch: repoData.defaultBranch
+      } : {
+        stars: 0,
+        forks: 0,
+        watchers: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        pushedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        defaultBranch: "main"
+      }
+    };
+    const config = await readReposConfig();
+    const existingIndex = config.repos.findIndex((t) => t.id === repo.id);
+    if (existingIndex >= 0) {
+      config.repos[existingIndex] = repoInfo;
+    } else {
+      config.repos.push(repoInfo);
+    }
+    await writeReposConfig(config);
+  } catch (error) {
+    relinka("error", "Failed to save repo:", String(error));
+    throw error;
+  }
+}
+export const TEMP_FULLSTACK_WEBSITE_TEMPLATE_OPTIONS = {
+  "blefnk/relivator-nextjs-template": {
+    label: `Relivator ${recommended}`,
+    value: "blefnk/relivator-nextjs-template",
+    hint: re.dim("Full-featured template with BetterAuth, Polar, and more")
+  },
+  "blefnk/versator-nextjs-template": {
+    label: `Versator ${experimental}`,
+    value: "blefnk/versator-nextjs-template",
+    hint: re.dim("Versatile template with Clerk, Stripe, and more")
+  },
+  "blefnk/next-react-ts-src-minimal": {
+    label: `Next.js Only ${experimental}`,
+    value: "blefnk/next-react-ts-src-minimal",
+    hint: re.dim("Essentials only: minimal Next.js with TypeScript")
+  }
+};
+export const TEMP_SEPARATED_WEBSITE_TEMPLATE_OPTIONS = {
+  "blefnk/relivator-docker-repo": {
+    label: `${experimental} Relivator Docker Repo`,
+    value: "blefnk/relivator-docker-repo",
+    hint: re.dim("Separated frontend and backend")
+  }
+};
+export const TEMP_VSCODE_TEMPLATE_OPTIONS = {
+  "microsoft/vscode-extension-samples": {
+    label: "VS Code Extension Sample",
+    value: "microsoft/vscode-extension-samples",
+    hint: re.dim("Official VS Code extension samples")
+  },
+  "microsoft/vscode-extension-template": {
+    label: "VS Code Extension Template",
+    value: "microsoft/vscode-extension-template",
+    hint: re.dim("Basic VS Code extension template")
+  }
+};
+export const TEMP_BROWSER_TEMPLATE_OPTIONS = {
+  "rsebrowser-extension": {
+    label: "Browser Extension Repo",
+    value: "rsebrowser-extension",
+    hint: re.dim("Browser extension starter repo")
+  }
+};

package/bin/app/utils/prompts/askAppOrLib.d.ts

@@ -0,0 +1 @@
+export declare function askAppOrLib(projectName: string): Promise<"app" | "lib">;

package/bin/app/utils/prompts/askAppOrLib.js

@@ -0,0 +1,30 @@
+import { re } from "@reliverse/relico";
+import { selectPrompt } from "@reliverse/rempts";
+const KNOWN_APPS = ["relivator"];
+const KNOWN_LIBS = ["recme", "reinit"];
+export async function askAppOrLib(projectName) {
+  if (KNOWN_APPS.includes(projectName)) {
+    return "app";
+  }
+  if (KNOWN_LIBS.includes(projectName)) {
+    return "lib";
+  }
+  const type = await selectPrompt({
+    title: "What type of project are you creating?",
+    content: `This will determine the config files to be generated. If you're unsure, choose ${re.bold("Web app")}.
+No worries\u2014you can always change it later by editing the project's rseg.`,
+    options: [
+      {
+        label: "Web app",
+        value: "app",
+        hint: "Includes desktop and mobile apps"
+      },
+      {
+        label: "Library",
+        value: "lib",
+        hint: "Includes clis and extensions"
+      }
+    ]
+  });
+  return type;
+}

package/bin/app/utils/prompts/askInstallDeps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Asks the user if they want to install dependencies and attempts to install them if confirmed.
+ * @param cwd The current working directory
+ * @returns true if dependencies are still missing (installation failed or user declined),
+ *          false if dependencies are now installed
+ */
+export declare function askInstallDeps(cwd: string): Promise<boolean>;

package/bin/app/utils/prompts/askInstallDeps.js

@@ -0,0 +1,40 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+import { installDependencies } from "nypm";
+export async function askInstallDeps(cwd) {
+  const DEPS_INSTALLED = false;
+  const DEPS_MISSING = true;
+  try {
+    const shouldInstall = await confirmPrompt({
+      title: "Dependencies are missing in your project. Would you like to install them?",
+      content: re.bold(
+        "\u{1F6A8} Note: Certain addons will be disabled until the dependencies are installed."
+      )
+    });
+    if (!shouldInstall) {
+      relinka("info", "Skipping dependency installation.");
+      return DEPS_MISSING;
+    }
+    relinka("info", "Installing dependencies...");
+    try {
+      await installDependencies({ cwd });
+      relinka("success", "Dependencies installed successfully");
+      return DEPS_INSTALLED;
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to install dependencies:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return DEPS_MISSING;
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "An unexpected error occurred during dependency installation:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return DEPS_MISSING;
+  }
+}

package/bin/app/utils/prompts/askOpenInIDE.d.ts

@@ -0,0 +1,5 @@
+export declare function askOpenInIDE({ isDev, projectPath, enforce, }: {
+    isDev: boolean;
+    projectPath: string;
+    enforce?: boolean;
+}): Promise<void>;

package/bin/app/utils/prompts/askOpenInIDE.js

@@ -0,0 +1,43 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+import { execa } from "execa";
+import { isVSCodeInstalled } from "../handlers/isAppInstalled.js";
+export async function askOpenInIDE({
+  isDev,
+  projectPath,
+  enforce = false
+}) {
+  if (isDev) {
+    return;
+  }
+  let shouldOpenIDE;
+  if (enforce) {
+    shouldOpenIDE = true;
+  } else {
+    shouldOpenIDE = await confirmPrompt({
+      title: "Do you want to open the project in your editor?",
+      defaultValue: false
+    });
+  }
+  if (!shouldOpenIDE) {
+    return;
+  }
+  const vscodeInstalled = isVSCodeInstalled();
+  relinka(
+    "verbose",
+    vscodeInstalled ? "Opening bootstrapped project in VSCode-based IDE..." : "Trying to open project in default IDE..."
+  );
+  try {
+    await execa("code", [projectPath], {
+      detached: true,
+      stdio: "ignore"
+    });
+  } catch (error) {
+    relinka(
+      "error",
+      "Error opening project in IDE:",
+      error instanceof Error ? error.message : String(error),
+      `Try manually: code ${projectPath}`
+    );
+  }
+}

package/bin/app/utils/prompts/askProjectName.d.ts

@@ -0,0 +1,3 @@
+export declare function askProjectName({ repoName }: {
+    repoName?: string;
+}): Promise<string>;

package/bin/app/utils/prompts/askProjectName.js

@@ -0,0 +1,21 @@
+import { inputPrompt, isValidName } from "@reliverse/rempts";
+import { generate } from "random-words";
+export async function askProjectName({ repoName = "" }) {
+  let defaultValue;
+  if (repoName) {
+    defaultValue = repoName.split("/").pop() ?? "";
+  } else {
+    defaultValue = generate({ exactly: 2, join: "-" });
+  }
+  const title = repoName ? "How should I name proceeding project?" : "How should I name your brand new project?";
+  const content = repoName ? "This name will be used to create the project directory." : "This name may be used to create the project directory, throughout the project, etc.";
+  const placeholder = repoName ? `Press <Enter> to use the repository name: ${defaultValue}` : `I've just generated a random name for you (press <Enter> to use it): ${defaultValue}`;
+  const name = await inputPrompt({
+    title,
+    content,
+    placeholder,
+    defaultValue,
+    validate: (value) => isValidName(value).isValid || `Invalid project name: ${value}`
+  });
+  return name.toString();
+}

package/bin/app/utils/prompts/askUsernameFrontend.d.ts

@@ -0,0 +1,2 @@
+import type { RseConfig } from "../../types/mod.js";
+export declare function askUsernameFrontend(config: RseConfig, shouldAskIfExists: boolean): Promise<string | null>;

package/bin/app/utils/prompts/askUsernameFrontend.js

@@ -0,0 +1,29 @@
+import { re } from "@reliverse/relico";
+import { deleteLastLine, inputPrompt } from "@reliverse/rempts";
+import { updateRseConfig } from "../../config/cfg-update.js";
+import { DEFAULT_CLI_USERNAME } from "../../config/constants.js";
+export async function askUsernameFrontend(config, shouldAskIfExists) {
+  if (!shouldAskIfExists && config.projectAuthor && config.projectAuthor !== "")
+    return config.projectAuthor;
+  const previousName = typeof config.projectAuthor === "string" ? config.projectAuthor : "";
+  const hasPreviousName = previousName !== "";
+  const placeholder = hasPreviousName ? previousName : DEFAULT_CLI_USERNAME;
+  const content = hasPreviousName ? `Last used name: ${re.cyanBright(placeholder)} (just press <Enter> to use it again)` : `You can press Enter to use the default name: ${re.cyanBright(DEFAULT_CLI_USERNAME)}`;
+  const userInput = await inputPrompt({
+    title: "Enter a name/username for the frontend (e.g. footer, contact page, etc.):",
+    content,
+    placeholder: hasPreviousName ? "No worries about @ symbol anywhere, I'll add it for you." : `[Default: ${placeholder}] No worries about @ symbol anywhere, I'll add it for you.`,
+    defaultValue: hasPreviousName ? previousName : DEFAULT_CLI_USERNAME
+  });
+  const trimmedInput = userInput.trim();
+  if (trimmedInput === "") {
+    if (hasPreviousName) {
+      return previousName;
+    }
+    await updateRseConfig(process.cwd(), { projectAuthor: DEFAULT_CLI_USERNAME }, false);
+    deleteLastLine();
+    return DEFAULT_CLI_USERNAME;
+  }
+  await updateRseConfig(process.cwd(), { projectAuthor: trimmedInput }, false);
+  return trimmedInput;
+}

package/bin/app/utils/prompts/askUsernameGithub.d.ts

@@ -0,0 +1,2 @@
+import type { ReliverseMemory } from "../schemaMemory.js";
+export declare function askUsernameGithub(memory: ReliverseMemory, frontendUsername: string): Promise<string>;

package/bin/app/utils/prompts/askUsernameGithub.js

@@ -0,0 +1,29 @@
+import { relinka } from "@reliverse/relinka";
+import { inputPrompt } from "@reliverse/rempts";
+import { updateReliverseMemory } from "../reliverseMemory.js";
+export async function askUsernameGithub(memory, frontendUsername) {
+  if (memory.githubUsername?.trim()) {
+    return memory.githubUsername;
+  }
+  const githubUsername = await inputPrompt({
+    title: `What's your GitHub username?`,
+    content: "If you don't have a GitHub account, you can create one for free at https://github.com/signup",
+    hint: `Leave empty if your GitHub username matches your frontend username and you want to use it: ${frontendUsername}`,
+    defaultValue: frontendUsername ?? "",
+    validate: (value) => {
+      const trimmed = value?.trim();
+      if (!trimmed) return "A GitHub username is required for the next steps.";
+      if (!/^[a-z\d](?:[a-z\d]|-(?=[a-z\d])){0,38}$/i.test(trimmed)) {
+        return "Invalid GitHub username format. It must be 1-39 characters long, contain only letters, numbers, or dashes, and cannot start or end with a dash.";
+      }
+      return true;
+    }
+  });
+  if (!githubUsername.trim()) {
+    relinka("error", "Invalid GitHub username provided.");
+    throw new Error("GitHub username input is invalid.");
+  }
+  await updateReliverseMemory({ githubUsername });
+  memory.githubUsername = githubUsername;
+  return githubUsername;
+}

package/bin/app/utils/prompts/shouldInitGit.d.ts

@@ -0,0 +1 @@
+export declare function shouldInitGit(isDev: boolean): Promise<boolean>;

package/bin/app/utils/prompts/shouldInitGit.js

@@ -0,0 +1,8 @@
+import { confirmPrompt } from "@reliverse/rempts";
+export async function shouldInitGit(isDev) {
+  return await confirmPrompt({
+    title: "Do you want to initialize a Git repository?",
+    content: "This will create a `.git` folder in your project.",
+    defaultValue: !isDev
+  });
+}

package/bin/app/utils/reliverseMemory.d.ts

@@ -0,0 +1,3 @@
+import type { ReliverseMemory } from "./schemaMemory";
+export declare function getOrCreateReliverseMemory(): Promise<ReliverseMemory>;
+export declare function updateReliverseMemory(data: Partial<ReliverseMemory>): Promise<void>;

package/bin/app/utils/reliverseMemory.js

@@ -0,0 +1,122 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { eq } from "drizzle-orm";
+import { memoryPath } from "../config/constants.js";
+import { db } from "../db/client.js";
+import { decrypt, encrypt } from "../db/config.js";
+import { configKeysTable, userDataTable } from "../db/schema.js";
+export async function getOrCreateReliverseMemory() {
+  if (!await fs.pathExists(path.dirname(memoryPath))) {
+    await ensuredir(path.dirname(memoryPath));
+  }
+  try {
+    const configRows = await db.select().from(configKeysTable);
+    const configData = {};
+    for (const row of configRows) {
+      try {
+        const decrypted = await decrypt(row.value);
+        try {
+          if (decrypted.startsWith("{") || decrypted.startsWith("[")) {
+            configData[row.key] = JSON.parse(decrypted);
+          } else {
+            configData[row.key] = decrypted;
+          }
+        } catch {
+          configData[row.key] = decrypted;
+        }
+      } catch {
+        configData[row.key] = "";
+      }
+    }
+    const userRows = await db.select().from(userDataTable);
+    const userData = userRows.reduce((acc, row) => {
+      try {
+        if (row.value.startsWith("{") || row.value.startsWith("[")) {
+          acc[row.key] = JSON.parse(row.value);
+        } else {
+          acc[row.key] = row.value;
+        }
+      } catch {
+        acc[row.key] = row.value;
+      }
+      return acc;
+    }, {});
+    return {
+      // Encrypted data
+      code: configData.code ?? "",
+      key: configData.key ?? "",
+      githubKey: configData.githubKey ?? "",
+      vercelKey: configData.vercelKey ?? "",
+      openaiKey: configData.openaiKey ?? "",
+      // Non-encrypted data
+      name: userData.name ?? "",
+      email: userData.email ?? "",
+      githubUsername: userData.githubUsername ?? "",
+      vercelTeamId: userData.vercelTeamId ?? "",
+      vercelTeamSlug: userData.vercelTeamSlug ?? ""
+    };
+  } catch (error) {
+    relinka(
+      "error",
+      "Error reading memory:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      code: "",
+      key: "",
+      githubKey: "",
+      vercelKey: "",
+      openaiKey: "",
+      name: "",
+      email: "",
+      githubUsername: "",
+      vercelTeamSlug: "",
+      vercelTeamId: ""
+    };
+  }
+}
+export async function updateReliverseMemory(data) {
+  try {
+    const encryptedEntries = Object.entries(data).filter(([key]) => ["code", "key", "githubKey", "vercelKey", "openaiKey"].includes(key)).filter(([_, value]) => value !== null && value !== void 0);
+    const configUpdates = [];
+    for (const [key, value] of encryptedEntries) {
+      const stringValue = typeof value === "object" ? JSON.stringify(value) : typeof value === "undefined" ? "" : String(value);
+      const encryptedValue = await encrypt(stringValue);
+      configUpdates.push({
+        key,
+        value: encryptedValue
+      });
+    }
+    const userDataUpdates = Object.entries(data).filter(
+      ([key]) => ["name", "email", "githubUsername", "vercelTeamSlug", "vercelTeamId"].includes(key)
+    ).filter(([_, value]) => value !== null && value !== void 0).map(([key, value]) => ({
+      key,
+      value: typeof value === "object" ? JSON.stringify(value) : typeof value === "undefined" ? "" : String(value)
+    }));
+    const keysToDelete = Object.entries(data).filter(([key]) => ["code", "key", "githubKey", "vercelKey", "openaiKey"].includes(key)).filter(([_, value]) => value === null).map(([key]) => key);
+    for (const key of keysToDelete) {
+      await db.delete(configKeysTable).where(eq(configKeysTable.key, key));
+    }
+    for (const update of configUpdates) {
+      await db.insert(configKeysTable).values(update).onConflictDoUpdate({
+        target: configKeysTable.key,
+        set: { value: update.value }
+      });
+    }
+    for (const update of userDataUpdates) {
+      await db.insert(userDataTable).values(update).onConflictDoUpdate({
+        target: userDataTable.key,
+        set: { value: update.value }
+      });
+    }
+    relinka("verbose", "Memory updated successfully");
+  } catch (error) {
+    relinka(
+      "error",
+      "Error updating memory:",
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  }
+}

package/bin/app/utils/replacements/reps-impl.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utility to extract author and project name from template URL
+ */
+export declare function extractRepoInfo(templateUrl: string): {
+    inputRepoAuthor: string;
+    inputRepoName: string;
+};
+export interface ReplaceConfig {
+    fileExtensions?: string[];
+    excludedDirs?: string[];
+    stringExclusions?: string[];
+    verbose?: boolean;
+    dryRun?: boolean;
+    skipBinaryFiles?: boolean;
+    maxConcurrency?: number;
+    stopOnError?: boolean;
+}
+/**
+ * Replaces specified strings in files under a target directory.
+ * Supports concurrent processing, binary file detection, and dry runs.
+ *
+ * @param projectPath - Root directory to process files in
+ * @param oldValues - Map of strings to replace (key) with their replacements (value)
+ * @param config - Optional configuration for file processing:
+ *   - fileExtensions: File types to process (e.g., [".js", ".ts"])
+ *   - excludedDirs: Directories to skip (e.g., ["node_modules"])
+ *   - stringExclusions: Strings to never replace
+ *   - verbose: Enable detailed logging
+ *   - dryRun: Preview changes without writing
+ *   - skipBinaryFiles: Skip processing of binary files
+ *   - maxConcurrency: Limit parallel processing
+ *   - stopOnError: Stop on first error
+ * @throws Error if target directory doesn't exist or processing fails
+ */
+export declare function replaceStringsInFiles(projectPath: string, oldValues: Record<string, string>, config?: ReplaceConfig): Promise<void>;