@acmecloud/core 1.0.2

package/src/session/index.ts

@@ -0,0 +1,129 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import os from 'os';
+import * as fs from 'fs';
+
+let db: Database.Database | null = null;
+const DB_DIR = path.join(os.homedir(), '.acmecode');
+const DB_PATH = path.join(DB_DIR, 'sessions.db');
+
+export interface Session {
+    id: string;
+    title: string;
+    updated_at: string;
+}
+
+export interface SessionMessage {
+    id: number;
+    session_id: string;
+    role: string;
+    content_json: string;
+    created_at: string;
+}
+
+export function initDb() {
+    if (db) return;
+
+    if (!fs.existsSync(DB_DIR)) {
+        fs.mkdirSync(DB_DIR, { recursive: true });
+    }
+
+    db = new Database(DB_PATH);
+
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content_json TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY(session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+}
+
+export function createSession(id: string, title?: string): Session {
+    initDb();
+    const titleToUse = title || `Session ${new Date().toLocaleString()}`;
+    const stmt = db!.prepare('INSERT INTO sessions (id, title) VALUES (?, ?)');
+    stmt.run(id, titleToUse);
+
+    return { id, title: titleToUse, updated_at: new Date().toISOString() };
+}
+
+export function saveMessages(sessionId: string, messages: any[]) {
+    initDb();
+
+    // Clear existing messages for this session to overwrite with the updated array
+    // This is a simple strategy since the messages array grows append-only
+    const deleteStmt = db!.prepare('DELETE FROM messages WHERE session_id = ?');
+    deleteStmt.run(sessionId);
+
+    const insertStmt = db!.prepare('INSERT INTO messages (session_id, role, content_json) VALUES (?, ?, ?)');
+
+    const insertMany = db!.transaction((msgs) => {
+        for (const msg of msgs) {
+            insertStmt.run(sessionId, msg.role, JSON.stringify(msg.content));
+        }
+    });
+
+    insertMany(messages);
+
+    // Auto-generate session title from the first user message
+    const userMsgs = messages.filter(m => m.role === 'user');
+    if (userMsgs.length === 1 && userMsgs[0]?.content) {
+        let firstText = '';
+        if (typeof userMsgs[0].content === 'string') firstText = userMsgs[0].content;
+        else if (Array.isArray(userMsgs[0].content)) {
+            firstText = userMsgs[0].content.find((c: any) => c.type === 'text')?.text || '';
+        }
+
+        if (firstText) {
+            // Remove slash commands like /skill foo
+            const cleanText = firstText.replace(/^\/\w+\s*/, '').trim();
+            if (cleanText) {
+                const newTitle = cleanText.length > 30 ? cleanText.slice(0, 27) + '...' : cleanText;
+
+                // Only update if it's currently a default generated timestamp title
+                const row = db!.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as { title: string } | undefined;
+                if (row && row.title.startsWith('Session ')) {
+                    const updateTitleStmt = db!.prepare('UPDATE sessions SET title = ? WHERE id = ?');
+                    updateTitleStmt.run(newTitle, sessionId);
+                }
+            }
+        }
+    }
+
+    // Update session timestamp
+    const updateStmt = db!.prepare('UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE id = ?');
+    updateStmt.run(sessionId);
+}
+
+export function loadSession(sessionId: string): any[] {
+    initDb();
+    const stmt = db!.prepare('SELECT role, content_json FROM messages WHERE session_id = ? ORDER BY id ASC');
+    const rows = stmt.all(sessionId) as { role: string, content_json: string }[];
+
+    return rows.map(row => ({
+        role: row.role,
+        content: JSON.parse(row.content_json)
+    }));
+}
+
+export function listSessions(): Session[] {
+    initDb();
+    const stmt = db!.prepare('SELECT id, title, updated_at FROM sessions ORDER BY updated_at DESC');
+    return stmt.all() as Session[];
+}
+
+export function deleteSession(sessionId: string) {
+    initDb();
+    const stmt = db!.prepare('DELETE FROM sessions WHERE id = ?');
+    stmt.run(sessionId);
+}

package/src/skills/index.ts

@@ -0,0 +1,86 @@
+import * as fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+export interface Skill {
+    name: string;
+    description: string;
+    content: string;
+}
+
+/**
+ * Searches upward from startDir for the given targets.
+ */
+async function findUpDirectories(startDir: string, targets: string[]): Promise<string[]> {
+    const results: string[] = [];
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+
+    while (true) {
+        for (const target of targets) {
+            const fullPath = path.join(current, target);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) {
+                    results.push(fullPath);
+                }
+            } catch {
+                // Ignore
+            }
+        }
+        if (current === root) break;
+        current = path.dirname(current);
+    }
+    return results;
+}
+
+export async function loadSkills(): Promise<Skill[]> {
+    const globalSkillsPath = path.join(os.homedir(), '.acmecode', 'skills');
+
+    // OpenCode patterns: .agents/skills, .claude/skills, .acmecode/skills
+    const searchTargets = [
+        '.acmecode/skills',
+        '.agents/skills',
+        '.claude/skills',
+    ];
+
+    const localSkillDirs = await findUpDirectories(process.cwd(), searchTargets);
+
+    // Priority: Lower directories in the tree (closer to project root) are processed first,
+    // and higher directories (closer to CWD) are processed last to overwrite.
+    // Global is processed first of all.
+    const allDirs = [globalSkillsPath, ...localSkillDirs.reverse()];
+    const skillsMap = new Map<string, Skill>();
+
+    for (const dir of allDirs) {
+        try {
+            const files = await fs.readdir(dir);
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    const content = await fs.readFile(path.join(dir, file), 'utf8');
+                    let name = file.replace('.md', '');
+
+                    // Improved parsing: Look for name and description in YAML frontmatter or content
+                    let description = `Skill ${name}`;
+
+                    // Try to extract name from frontmatter
+                    const nameMatch = content.match(/^name:\s*(.*)/m);
+                    if (nameMatch) name = nameMatch[1].trim();
+
+                    const descriptionMatch = content.match(/^description:\s*(.*)/m);
+                    if (descriptionMatch) {
+                        description = descriptionMatch[1].trim();
+                    }
+
+                    skillsMap.set(name, { name, description, content });
+                }
+            }
+        } catch (err: any) {
+            if (err.code !== 'ENOENT') {
+                console.warn(`Could not read skills directory ${dir}: ${err.message}`);
+            }
+        }
+    }
+
+    return Array.from(skillsMap.values());
+}

package/src/tools/batch.ts

@@ -0,0 +1,73 @@
+export const BATCH_WHITELIST = new Set([
+  "read_file",
+  "webfetch",
+  "websearch",
+  "codesearch",
+  "grep_search",
+  "list_dir",
+  "lsp",
+]);
+
+export async function executeBatch(
+  args: any,
+  toolExecutors: Record<string, (args: any) => Promise<string>>,
+): Promise<string> {
+  let calls: any[] = [];
+
+  // 支持多种格式
+  if (Array.isArray(args)) {
+    calls = args;
+  } else if (args.calls && Array.isArray(args.calls)) {
+    calls = args.calls;
+  } else if (args.tools) {
+    // LLM 可能传 JSON 字符串
+    if (typeof args.tools === "string") {
+      try {
+        calls = JSON.parse(args.tools);
+      } catch {
+        return "Error: Failed to parse tools JSON string.";
+      }
+    } else if (Array.isArray(args.tools)) {
+      calls = args.tools;
+    }
+  }
+
+  if (!Array.isArray(calls) || calls.length === 0) {
+    return "Error: No tool calls provided in batch.";
+  }
+
+  const promises = calls.map(async (call, index) => {
+    const tool = call.tool || call.name;
+
+    // 参数可能在 arguments、parameters，或直接在顶层
+    let toolArgs = call.arguments || call.parameters;
+    if (!toolArgs || typeof toolArgs !== "object") {
+      // 提取除了 name/tool 以外的字段作为参数
+      const { name, tool: _, ...rest } = call;
+      toolArgs = rest;
+    }
+
+    if (!tool) {
+      return `[Call ${index + 1}] Error: Missing tool name.`;
+    }
+
+    if (!BATCH_WHITELIST.has(tool)) {
+      return `[Call ${index + 1}: ${tool}] Error: Tool "${tool}" is not allowed in batch mode (only idempotent/read tools are permitted).`;
+    }
+
+    const executor = toolExecutors[tool];
+    if (!executor) {
+      return `[Call ${index + 1}: ${tool}] Error: Tool "${tool}" not found.`;
+    }
+
+    try {
+      const result = await executor(toolArgs);
+      return `[Call ${index + 1}: ${tool}]\n${result}`;
+    } catch (err: any) {
+      return `[Call ${index + 1}: ${tool}] Error: ${err.message}`;
+    }
+  });
+
+  const results = await Promise.all(promises);
+  return results.join("\n\n" + "─".repeat(40) + "\n\n");
+}

package/src/tools/browser.ts

@@ -0,0 +1,95 @@
+import { chromium, Browser, Page } from 'playwright';
+import { analyzeImage } from '../llm/vision.js';
+import { loadModelConfig } from '../config/index.js';
+import * as fs from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import path from 'path';
+
+let browser: Browser | null = null;
+let page: Page | null = null;
+
+async function getBrowser() {
+    try {
+        if (!browser) {
+            browser = await chromium.launch({ headless: true });
+        }
+        if (!page) {
+            const context = await browser.newContext({
+                viewport: { width: 1280, height: 720 }
+            });
+            page = await context.newPage();
+        }
+        return { browser, page };
+    } catch (err: any) {
+        if (err.message.includes('executable') || err.message.includes('not found')) {
+            throw new Error(`Browser not found. Please run: npx playwright install chromium`);
+        }
+        throw err;
+    }
+}
+
+export async function executeBrowserAction(args: { action: string, url?: string, selector?: string, text?: string }): Promise<string> {
+    const { page } = await getBrowser();
+    const config = loadModelConfig();
+
+    try {
+        switch (args.action) {
+            case 'navigate':
+                if (!args.url) return 'Error: URL is required for navigate action.';
+                await page.goto(args.url, { waitUntil: 'networkidle' });
+                const title = await page.title();
+                return `Successfully navigated to ${args.url}. Page title: ${title}`;
+
+            case 'screenshot':
+                const screenshot = await page.screenshot({ fullPage: false });
+                const base64 = screenshot.toString('base64');
+
+                // Save to disk
+                const screenshotDir = path.resolve(process.cwd(), '.acmecode', 'screenshots');
+                if (!existsSync(screenshotDir)) {
+                    mkdirSync(screenshotDir, { recursive: true });
+                }
+                const filename = `screenshot_${new Date().toISOString().replace(/[:.]/g, '-')}.png`;
+                const filePath = path.join(screenshotDir, filename);
+                await fs.writeFile(filePath, screenshot);
+
+                const stats = `Screenshot saved to: ${path.relative(process.cwd(), filePath)}`;
+
+                // Delegate to vision model if configured
+                if (config.visionModel) {
+                    const analysis = await analyzeImage(base64, config);
+                    return `${stats}\n\n${analysis}`;
+                }
+
+                return stats;
+
+            case 'click':
+                if (!args.selector) return 'Error: Selector is required for click action.';
+                await page.click(args.selector);
+                return `Clicked element: ${args.selector}`;
+
+            case 'type':
+                if (!args.selector || !args.text) return 'Error: Selector and text are required for type action.';
+                await page.fill(args.selector, args.text);
+                return `Typed "${args.text}" into ${args.selector}`;
+
+            case 'scroll':
+                await page.mouse.wheel(0, 500);
+                return 'Scrolled down.';
+
+            default:
+                return `Error: Unknown action "${args.action}"`;
+        }
+    } catch (err: any) {
+        return `Browser error: ${err.message}`;
+    }
+}
+
+// Cleanup function to be called on process exit
+export async function closeBrowser() {
+    if (browser) {
+        await browser.close();
+        browser = null;
+        page = null;
+    }
+}

package/src/tools/edit.ts

@@ -0,0 +1,317 @@
+import path from 'path';
+import * as fs from 'fs/promises';
+
+// ── Fuzzy Replacement Logic (Ported from opencode) ──
+
+export type Replacer = (content: string, find: string) => Generator<string, void, unknown>;
+
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0;
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+
+function levenshtein(a: string, b: string): number {
+    if (a === "" || b === "") return Math.max(a.length, b.length);
+    const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+        Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+    );
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+
+export const SimpleReplacer: Replacer = function* (_content, find) {
+    yield find;
+};
+
+export const LineTrimmedReplacer: Replacer = function* (content, find) {
+    const originalLines = content.split("\n");
+    const searchLines = find.split("\n");
+    if (searchLines[searchLines.length - 1] === "") searchLines.pop();
+
+    for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+        let matches = true;
+        for (let j = 0; j < searchLines.length; j++) {
+            if (originalLines[i + j].trim() !== searchLines[j].trim()) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            let matchStartIndex = 0;
+            for (let k = 0; k < i; k++) matchStartIndex += originalLines[k].length + 1;
+            let matchEndIndex = matchStartIndex;
+            for (let k = 0; k < searchLines.length; k++) {
+                matchEndIndex += originalLines[i + k].length;
+                if (k < searchLines.length - 1) matchEndIndex += 1;
+            }
+            yield content.substring(matchStartIndex, matchEndIndex);
+        }
+    }
+};
+
+export const BlockAnchorReplacer: Replacer = function* (content, find) {
+    const originalLines = content.split("\n");
+    const searchLines = find.split("\n");
+    if (searchLines.length < 3) return;
+    if (searchLines[searchLines.length - 1] === "") searchLines.pop();
+
+    const firstLineSearch = searchLines[0].trim();
+    const lastLineSearch = searchLines[searchLines.length - 1].trim();
+    const searchBlockSize = searchLines.length;
+
+    const candidates: Array<{ startLine: number; endLine: number }> = [];
+    for (let i = 0; i < originalLines.length; i++) {
+        if (originalLines[i].trim() !== firstLineSearch) continue;
+        for (let j = i + 2; j < originalLines.length; j++) {
+            if (originalLines[j].trim() === lastLineSearch) {
+                candidates.push({ startLine: i, endLine: j });
+                break;
+            }
+        }
+    }
+
+    if (candidates.length === 0) return;
+
+    if (candidates.length === 1) {
+        const { startLine, endLine } = candidates[0];
+        const actualBlockSize = endLine - startLine + 1;
+        let similarity = 0;
+        let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+
+        if (linesToCheck > 0) {
+            for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+                const originalLine = originalLines[startLine + j].trim();
+                const searchLine = searchLines[j].trim();
+                const maxLen = Math.max(originalLine.length, searchLine.length);
+                if (maxLen === 0) continue;
+                const distance = levenshtein(originalLine, searchLine);
+                similarity += (1 - distance / maxLen) / linesToCheck;
+                if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) break;
+            }
+        } else {
+            similarity = 1.0;
+        }
+
+        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+            let matchStartIndex = 0;
+            for (let k = 0; k < startLine; k++) matchStartIndex += originalLines[k].length + 1;
+            let matchEndIndex = matchStartIndex;
+            for (let k = startLine; k <= endLine; k++) {
+                matchEndIndex += originalLines[k].length;
+                if (k < endLine) matchEndIndex += 1;
+            }
+            yield content.substring(matchStartIndex, matchEndIndex);
+        }
+        return;
+    }
+
+    let bestMatch: { startLine: number; endLine: number } | null = null;
+    let maxSimilarity = -1;
+
+    for (const candidate of candidates) {
+        const { startLine, endLine } = candidate;
+        const actualBlockSize = endLine - startLine + 1;
+        let similarity = 0;
+        let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+
+        if (linesToCheck > 0) {
+            for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+                const originalLine = originalLines[startLine + j].trim();
+                const searchLine = searchLines[j].trim();
+                const maxLen = Math.max(originalLine.length, searchLine.length);
+                if (maxLen === 0) continue;
+                const distance = levenshtein(originalLine, searchLine);
+                similarity += 1 - distance / maxLen;
+            }
+            similarity /= linesToCheck;
+        } else {
+            similarity = 1.0;
+        }
+
+        if (similarity > maxSimilarity) {
+            maxSimilarity = similarity;
+            bestMatch = candidate;
+        }
+    }
+
+    if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+        const { startLine, endLine } = bestMatch;
+        let matchStartIndex = 0;
+        for (let k = 0; k < startLine; k++) matchStartIndex += originalLines[k].length + 1;
+        let matchEndIndex = matchStartIndex;
+        for (let k = startLine; k <= endLine; k++) {
+            matchEndIndex += originalLines[k].length;
+            if (k < endLine) matchEndIndex += 1;
+        }
+        yield content.substring(matchStartIndex, matchEndIndex);
+    }
+};
+
+export const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
+    const normalizeWhitespace = (text: string) => text.replace(/\s+/g, " ").trim();
+    const normalizedFind = normalizeWhitespace(find);
+
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (normalizeWhitespace(line) === normalizedFind) {
+            yield line;
+        } else {
+            const normalizedLine = normalizeWhitespace(line);
+            if (normalizedLine.includes(normalizedFind)) {
+                const words = find.trim().split(/\s+/);
+                if (words.length > 0) {
+                    const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+                    try {
+                        const match = line.match(new RegExp(pattern));
+                        if (match) yield match[0];
+                    } catch { }
+                }
+            }
+        }
+    }
+
+    const findLines = find.split("\n");
+    if (findLines.length > 1) {
+        for (let i = 0; i <= lines.length - findLines.length; i++) {
+            const block = lines.slice(i, i + findLines.length);
+            if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+                yield block.join("\n");
+            }
+        }
+    }
+};
+
+export const IndentationFlexibleReplacer: Replacer = function* (content, find) {
+    const removeIndentation = (text: string) => {
+        const lines = text.split("\n");
+        const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+        if (nonEmptyLines.length === 0) return text;
+        const minIndent = Math.min(...nonEmptyLines.map(line => line.match(/^(\s*)/)?.[1].length ?? 0));
+        return lines.map((line) => (line.trim().length === 0 ? line : line.slice(minIndent))).join("\n");
+    };
+
+    const normalizedFind = removeIndentation(find);
+    const contentLines = content.split("\n");
+    const findLines = find.split("\n");
+
+    for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+        const block = contentLines.slice(i, i + findLines.length).join("\n");
+        if (removeIndentation(block) === normalizedFind) yield block;
+    }
+};
+
+export const EscapeNormalizedReplacer: Replacer = function* (content, find) {
+    const unescapeString = (str: string): string => {
+        return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+            switch (capturedChar) {
+                case "n": return "\n";
+                case "t": return "\t";
+                case "r": return "\r";
+                default: return capturedChar === match[1] ? match[1] : match;
+            }
+        });
+    };
+    const unescapedFind = unescapeString(find);
+    if (content.includes(unescapedFind)) yield unescapedFind;
+
+    const lines = content.split("\n");
+    const findLines = unescapedFind.split("\n");
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = lines.slice(i, i + findLines.length).join("\n");
+        if (unescapeString(block) === unescapedFind) yield block;
+    }
+};
+
+export const MultiOccurrenceReplacer: Replacer = function* (content, find) {
+    let startIndex = 0;
+    while (true) {
+        const index = content.indexOf(find, startIndex);
+        if (index === -1) break;
+        yield find;
+        startIndex = index + find.length;
+    }
+};
+
+export const TrimmedBoundaryReplacer: Replacer = function* (content, find) {
+    const trimmedFind = find.trim();
+    if (trimmedFind === find) return;
+    if (content.includes(trimmedFind)) yield trimmedFind;
+
+    const lines = content.split("\n");
+    const findLines = find.split("\n");
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = lines.slice(i, i + findLines.length).join("\n");
+        if (block.trim() === trimmedFind) yield block;
+    }
+};
+
+export const ContextAwareReplacer: Replacer = function* (content, find) {
+    const findLines = find.split("\n");
+    if (findLines.length < 3) return;
+    if (findLines[findLines.length - 1] === "") findLines.pop();
+
+    const contentLines = content.split("\n");
+    const firstLine = findLines[0].trim();
+    const lastLine = findLines[findLines.length - 1].trim();
+
+    for (let i = 0; i < contentLines.length; i++) {
+        if (contentLines[i].trim() !== firstLine) continue;
+        for (let j = i + 2; j < contentLines.length; j++) {
+            if (contentLines[j].trim() === lastLine) {
+                const blockLines = contentLines.slice(i, j + 1);
+                const block = blockLines.join("\n");
+                if (blockLines.length === findLines.length) {
+                    let matchingLines = 0;
+                    let totalNonEmptyLines = 0;
+                    for (let k = 1; k < blockLines.length - 1; k++) {
+                        const blockLine = blockLines[k].trim();
+                        const findLine = findLines[k].trim();
+                        if (blockLine.length > 0 || findLine.length > 0) {
+                            totalNonEmptyLines++;
+                            if (blockLine === findLine) matchingLines++;
+                        }
+                    }
+                    if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
+                        yield block;
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+    }
+};
+
+export function replaceCode(content: string, oldString: string, newString: string, replaceAll = false): string {
+    if (oldString === newString) throw new Error("No changes to apply: oldString and newString are identical.");
+    let notFound = true;
+
+    for (const replacer of [
+        SimpleReplacer,
+        LineTrimmedReplacer,
+        BlockAnchorReplacer,
+        WhitespaceNormalizedReplacer,
+        IndentationFlexibleReplacer,
+        EscapeNormalizedReplacer,
+        TrimmedBoundaryReplacer,
+        ContextAwareReplacer,
+        MultiOccurrenceReplacer,
+    ]) {
+        for (const search of replacer(content, oldString)) {
+            const index = content.indexOf(search);
+            if (index === -1) continue;
+            notFound = false;
+            if (replaceAll) return content.replaceAll(search, newString);
+            const lastIndex = content.lastIndexOf(search);
+            if (index !== lastIndex) continue;
+            return content.substring(0, index) + newString + content.substring(index + search.length);
+        }
+    }
+
+    if (notFound) throw new Error("Could not find oldString in the file. It must match exactly, including whitespace, indentation, and line endings.");
+    throw new Error("Found multiple matches for oldString. Provide more surrounding context to make the match unique.");
+}