oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/components/rules/dist/tool-paths.js

@@ -1,168 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-const COMMAND_TOOL_NAMES = new Set(["bash", "shell_command", "exec_command"]);
-const TRACKED_TOOL_NAMES = new Set([
-    "read",
-    "read_file",
-    "mcp__filesystem__read_file",
-    "mcp__filesystem__read_multiple_files",
-    "mcp__filesystem__write_file",
-    "mcp__filesystem__edit_file",
-    "write",
-    "edit",
-    "multiedit",
-    "multi_edit",
-    "apply_patch",
-    "bash",
-    "shell_command",
-    "exec_command",
-]);
-export function extractCodexToolPaths(input, cwd) {
-    const toolName = input.tool_name.toLowerCase();
-    if (!TRACKED_TOOL_NAMES.has(toolName) || isFailedToolResponse(input.tool_response)) {
-        return [];
-    }
-    const paths = new Set();
-    const toolInput = isRecord(input.tool_input) ? input.tool_input : {};
-    addCommonPathFields(paths, toolInput, cwd);
-    addPatchPayloadPaths(paths, toolInput, cwd);
-    addPatchRecordPaths(paths, toolInput["files"], cwd);
-    addPatchRecordPaths(paths, toolInput["changes"], cwd);
-    if (COMMAND_TOOL_NAMES.has(toolName)) {
-        const command = stringProperty(toolInput, "command") ?? stringProperty(toolInput, "cmd");
-        const workdir = stringProperty(toolInput, "workdir") ?? stringProperty(toolInput, "cwd");
-        addCommandPaths(paths, command, workdir === undefined ? cwd : resolvePath(cwd, workdir));
-    }
-    return [...paths];
-}
-function addCommonPathFields(paths, input, cwd) {
-    for (const key of ["path", "filePath", "file_path", "target", "targetPath", "target_path"]) {
-        addPath(paths, input[key], cwd, false);
-    }
-    for (const key of ["paths", "filePaths", "file_paths"]) {
-        addPathArray(paths, input[key], cwd, false);
-    }
-}
-function addPatchPayloadPaths(paths, input, cwd) {
-    for (const key of ["input", "patch", "command", "cmd"]) {
-        const value = input[key];
-        if (typeof value === "string") {
-            addPatchHeaderPaths(paths, value, cwd);
-        }
-    }
-}
-function addPatchHeaderPaths(paths, patch, cwd) {
-    for (const line of patch.split("\n")) {
-        for (const prefix of ["*** Add File: ", "*** Update File: ", "*** Move to: "]) {
-            if (line.startsWith(prefix)) {
-                addPath(paths, line.slice(prefix.length).trim(), cwd, false);
-            }
-        }
-    }
-}
-function addPatchRecordPaths(paths, value, cwd) {
-    if (!Array.isArray(value))
-        return;
-    for (const item of value) {
-        if (typeof item === "string") {
-            addPath(paths, item, cwd, false);
-            continue;
-        }
-        if (!isRecord(item))
-            continue;
-        addCommonPathFields(paths, item, cwd);
-        for (const key of ["movePath", "move_path", "to", "from"]) {
-            addPath(paths, item[key], cwd, false);
-        }
-    }
-}
-function addCommandPaths(paths, command, cwd) {
-    if (command === undefined)
-        return;
-    for (const token of tokenizeShell(command)) {
-        if (token.length === 0 || token.startsWith("-") || token.includes("*")) {
-            continue;
-        }
-        addPath(paths, token, cwd, true);
-    }
-}
-function addPathArray(paths, value, cwd, mustExist) {
-    if (!Array.isArray(value))
-        return;
-    for (const item of value) {
-        addPath(paths, item, cwd, mustExist);
-    }
-}
-function addPath(paths, value, cwd, mustExist) {
-    if (typeof value !== "string" || value.length === 0 || looksLikeUrl(value)) {
-        return;
-    }
-    const path = resolvePath(cwd, value);
-    if (mustExist && !isExistingFile(path)) {
-        return;
-    }
-    paths.add(path);
-}
-function resolvePath(cwd, filePath) {
-    return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
-}
-function isExistingFile(filePath) {
-    try {
-        return existsSync(filePath) && statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function looksLikeUrl(value) {
-    return /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value);
-}
-function stringProperty(value, key) {
-    const property = value[key];
-    return typeof property === "string" && property.length > 0 ? property : undefined;
-}
-function tokenizeShell(command) {
-    const tokens = [];
-    let current = "";
-    let quote = null;
-    let escaped = false;
-    for (const character of command) {
-        if (escaped) {
-            current += character;
-            escaped = false;
-            continue;
-        }
-        if (character === "\\") {
-            escaped = true;
-            continue;
-        }
-        if ((character === "'" || character === '"') && quote === null) {
-            quote = character;
-            continue;
-        }
-        if (quote === character) {
-            quote = null;
-            continue;
-        }
-        if (quote === null && /\s/.test(character)) {
-            if (current.length > 0) {
-                tokens.push(current);
-                current = "";
-            }
-            continue;
-        }
-        current += character;
-    }
-    if (current.length > 0) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFailedToolResponse(value) {
-    if (!isRecord(value))
-        return false;
-    return (value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error");
-}

package/packages/omo-codex/plugin/components/rules/dist/transcript-rule-filter.d.ts

@@ -1,4 +0,0 @@
-import type { LoadedRule } from "./rules/types.js";
-import type { TranscriptSearchOptions } from "./transcript-search.js";
-export declare function filterRulesAlreadyInTranscript(rules: ReadonlyArray<LoadedRule>, transcriptPath: string | null, markInjected: (rule: LoadedRule) => void, options?: TranscriptSearchOptions): LoadedRule[];
-export declare function filterRulesNotInTranscriptText(rules: ReadonlyArray<LoadedRule>, transcriptText: string | null, markInjected: (rule: LoadedRule) => void): LoadedRule[];

package/packages/omo-codex/plugin/components/rules/dist/transcript-rule-filter.js

@@ -1,49 +0,0 @@
-import { readTranscriptSearchText } from "./transcript-search.js";
-export function filterRulesAlreadyInTranscript(rules, transcriptPath, markInjected, options = {}) {
-    if (rules.length === 0 || transcriptPath === null) {
-        return [...rules];
-    }
-    const transcriptText = readTranscriptSearchText(transcriptPath, options);
-    return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
-}
-export function filterRulesNotInTranscriptText(rules, transcriptText, markInjected) {
-    if (rules.length === 0 || transcriptText === null) {
-        return [...rules];
-    }
-    const pendingRules = [];
-    for (const rule of rules) {
-        if (isRuleAlreadyInTranscript(rule, transcriptText)) {
-            markInjected(rule);
-            continue;
-        }
-        pendingRules.push(rule);
-    }
-    return pendingRules;
-}
-function isRuleAlreadyInTranscript(rule, transcriptText) {
-    const staticReferenceNeedles = [
-        `- [${displayFilename(rule)}]{${rule.path}}`,
-        `- [${displayFilename(rule)}]{${rule.realPath}}`,
-    ];
-    if (staticReferenceNeedles.some((needle) => transcriptText.includes(needle))) {
-        return true;
-    }
-    const bodyNeedle = rule.body.trim().slice(0, 2_000);
-    if (bodyNeedle.length === 0 || !transcriptText.includes(bodyNeedle)) {
-        return false;
-    }
-    const markers = [
-        `Instructions from: ${rule.path}`,
-        `Instructions from: ${rule.realPath}`,
-        rule.relativePath.length === 0 ? null : rule.relativePath,
-    ].filter((marker) => marker !== null);
-    return markers.some((marker) => transcriptText.includes(marker));
-}
-function displayFilename(rule) {
-    const normalizedPath = rule.relativePath.length > 0 ? rule.relativePath : rule.path;
-    const segments = normalizedPath
-        .replace(/\\/g, "/")
-        .split("/")
-        .filter((segment) => segment.length > 0);
-    return segments.at(-1) ?? normalizedPath;
-}

package/packages/omo-codex/plugin/components/rules/dist/transcript-search.d.ts

@@ -1,4 +0,0 @@
-export interface TranscriptSearchOptions {
-    readonly latestCompactedReplacementOnly?: boolean;
-}
-export declare function readTranscriptSearchText(transcriptPath: string, options?: TranscriptSearchOptions): string | null;

package/packages/omo-codex/plugin/components/rules/dist/transcript-search.js

@@ -1,91 +0,0 @@
-import { readFileSync } from "node:fs";
-export function readTranscriptSearchText(transcriptPath, options = {}) {
-    try {
-        const rawTranscript = readFileSync(transcriptPath, "utf8");
-        if (options.latestCompactedReplacementOnly === true) {
-            return latestCompactedReplacementSearchText(rawTranscript);
-        }
-        return [rawTranscript, ...collectJsonLineStrings(rawTranscript)].join("\n");
-    }
-    catch (error) {
-        if (!(error instanceof Error)) {
-            throw error;
-        }
-        return null;
-    }
-}
-function latestCompactedReplacementSearchText(rawTranscript) {
-    const lines = rawTranscript.split(/\r?\n/);
-    let latestCompactedLineIndex = -1;
-    let replacementHistory = null;
-    for (const [index, line] of lines.entries()) {
-        const parsed = parseJsonLine(line);
-        if (!isRecord(parsed) || parsed["type"] !== "compacted") {
-            continue;
-        }
-        const payload = parsed["payload"];
-        if (!isRecord(payload)) {
-            continue;
-        }
-        const candidateReplacementHistory = payload["replacement_history"];
-        if (!Array.isArray(candidateReplacementHistory)) {
-            continue;
-        }
-        latestCompactedLineIndex = index;
-        replacementHistory = candidateReplacementHistory;
-    }
-    if (replacementHistory === null) {
-        return null;
-    }
-    const values = [];
-    collectStrings(replacementHistory, values);
-    const laterTranscript = lines.slice(latestCompactedLineIndex + 1).join("\n");
-    values.push(laterTranscript, ...collectJsonLineStrings(laterTranscript));
-    return values.join("\n");
-}
-function collectJsonLineStrings(rawTranscript) {
-    const values = [];
-    for (const line of rawTranscript.split(/\r?\n/)) {
-        const parsed = parseJsonLine(line);
-        if (parsed !== null) {
-            collectStrings(parsed, values);
-        }
-    }
-    return values;
-}
-function parseJsonLine(line) {
-    if (line.trim().length === 0) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(line);
-        return parsed;
-    }
-    catch (error) {
-        if (!(error instanceof Error)) {
-            throw error;
-        }
-        return null;
-    }
-}
-function collectStrings(value, output) {
-    if (typeof value === "string") {
-        output.push(value);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            collectStrings(item, output);
-        }
-        return;
-    }
-    if (!isRecord(value)) {
-        return;
-    }
-    for (const item of Object.values(value)) {
-        collectStrings(item, output);
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/packages/omo-codex/plugin/components/rules/src/rules/cache.ts

@@ -1,64 +0,0 @@
-import type { LoadedRule, SessionState } from "./types.js";
-
-const DYNAMIC_SESSION_KEY = "__pi-rules-session__";
-
-export function createSessionState(cwd?: string): SessionState {
-	return {
-		cwd,
-		staticDedup: new Set(),
-		dynamicDedup: new Map(),
-		dynamicTargetFingerprints: new Map(),
-		loadedRules: [],
-		diagnostics: [],
-	};
-}
-
-export function staticDedupKey(cwd: string, rulePath: string, contentHash: string): string {
-	return `${cwd}::${rulePath}::${contentHash}`;
-}
-
-export function dynamicDedupKey(rulePath: string, contentHash: string): string {
-	return `${rulePath}::${contentHash}`;
-}
-
-export function markStaticInjected(state: SessionState, rule: LoadedRule): boolean {
-	const key = staticDedupKey(state.cwd ?? "", rule.realPath, rule.contentHash);
-	if (state.staticDedup.has(key)) {
-		return false;
-	}
-
-	state.staticDedup.add(key);
-	return true;
-}
-
-export function markDynamicInjected(state: SessionState, rule: LoadedRule): boolean {
-	let keys = state.dynamicDedup.get(DYNAMIC_SESSION_KEY);
-	if (keys === undefined) {
-		keys = new Set();
-		state.dynamicDedup.set(DYNAMIC_SESSION_KEY, keys);
-	}
-
-	const key = dynamicDedupKey(rule.realPath, rule.contentHash);
-	if (keys.has(key)) {
-		return false;
-	}
-
-	keys.add(key);
-	return true;
-}
-
-export function isStaticInjected(state: SessionState, rule: LoadedRule): boolean {
-	return state.staticDedup.has(staticDedupKey(state.cwd ?? "", rule.realPath, rule.contentHash));
-}
-
-export function isDynamicInjected(state: SessionState, rule: LoadedRule): boolean {
-	return state.dynamicDedup.get(DYNAMIC_SESSION_KEY)?.has(dynamicDedupKey(rule.realPath, rule.contentHash)) === true;
-}
-
-export function clearSession(state: SessionState): void {
-	state.staticDedup.clear();
-	state.dynamicDedup.clear();
-	state.dynamicTargetFingerprints.clear();
-	state.loadedRules.length = 0;
-	state.diagnostics.length = 0;
-}

package/packages/omo-codex/plugin/components/rules/src/rules/constants.ts

@@ -1,122 +0,0 @@
-import type { RuleSource } from "./types.js";
-
-/**
- * Project root marker files / directories used by `findProjectRoot`.
- * Walks UP from cwd until any of these is found in the directory.
- */
-export const PROJECT_MARKERS: readonly string[] = [
-	".git",
-	"pnpm-workspace.yaml",
-	"package.json",
-	"pyproject.toml",
-	"Cargo.toml",
-	"go.mod",
-	".venv",
-];
-
-/**
- * Project rule subdirectories. First tuple element is the parent dir under
- * the project root, second is the subdir scanned recursively.
- */
-export const PROJECT_RULE_SUBDIRS: ReadonlyArray<readonly [string, string]> = [
-	[".omo", "rules"],
-	[".claude", "rules"],
-	[".cursor", "rules"],
-	[".github", "instructions"],
-];
-
-/**
- * Single-file project rules (always apply, frontmatter optional).
- */
-export const PROJECT_SINGLE_FILES: readonly string[] = [".github/copilot-instructions.md", "CONTEXT.md"];
-
-/**
- * User-home rule directories.
- */
-export const USER_HOME_RULE_SUBDIRS: readonly string[] = [".omo/rules", ".opencode/rules", ".claude/rules"];
-
-/**
- * User-home single-file rules. The first one to exist wins per "first-match" semantics.
- */
-export const USER_HOME_SINGLE_FILES: readonly string[] = [];
-
-/**
- * Bundled plugin rule directory relative to the rules component root.
- */
-export const BUNDLED_RULE_SUBDIR = "bundled-rules";
-
-/**
- * File extensions accepted as rule files in scanned directories.
- */
-export const RULE_FILE_EXTENSIONS: readonly string[] = [".md", ".mdc"];
-
-/**
- * Per-rule source priority for deterministic ordering. Lower = earlier.
- */
-export const SOURCE_PRIORITY: ReadonlyMap<RuleSource, number> = new Map([
-	[".omo/rules", 0],
-	[".claude/rules", 1],
-	[".cursor/rules", 2],
-	[".github/instructions", 3],
-	[".github/copilot-instructions.md", 4],
-	["CONTEXT.md", 7],
-	["~/.omo/rules", 100],
-	["~/.opencode/rules", 101],
-	["~/.claude/rules", 102],
-	["plugin-bundled", 200],
-]);
-
-/**
- * Distance value assigned to global / user-home rules.
- */
-export const GLOBAL_DISTANCE = 9999;
-
-/**
- * Per-rule body character cap (default).
- */
-export const DEFAULT_MAX_RULE_CHARS = 12000;
-
-export const DEFAULT_MAX_SCAN_FILES = 1000;
-
-/**
- * Total injected chars per tool result (default).
- */
-export const DEFAULT_MAX_RESULT_CHARS = 40000;
-
-export const DEFAULT_POST_COMPACT_MAX_RULE_CHARS = 3500;
-
-export const DEFAULT_POST_COMPACT_MAX_RESULT_CHARS = 4000;
-
-/**
- * Per-rule / total caps for dynamic (PostToolUse) injection. Kept far below the
- * static defaults so mid-session rule matches stay lightweight.
- */
-export const DEFAULT_DYNAMIC_MAX_RULE_CHARS = 4000;
-
-export const DEFAULT_DYNAMIC_MAX_RESULT_CHARS = 10000;
-
-/**
- * Per-rule / total caps for UserPromptSubmit static injection. SessionStart
- * keeps the full budget; prompt-time stragglers inject at a reduced size.
- */
-export const DEFAULT_PROMPT_MAX_RULE_CHARS = 6000;
-
-export const DEFAULT_PROMPT_MAX_RESULT_CHARS = 16000;
-
-/**
- * Truncation marker template. `{path}` is replaced with the relative path.
- */
-export const TRUNCATION_NOTICE = "\n\n[Truncated. Full: {path}]";
-
-/**
- * Directories excluded by the recursive scanner regardless of glob settings.
- */
-export const SCANNER_EXCLUDED_DIRS: readonly string[] = [
-	"node_modules",
-	".git",
-	"dist",
-	"build",
-	".turbo",
-	".next",
-	"coverage",
-];

package/packages/omo-codex/plugin/components/rules/src/rules/engine-dynamic-cache.ts

@@ -1,87 +0,0 @@
-import { dirname, resolve } from "node:path";
-import { pathBasesForTarget, toPosixPath } from "./engine-paths.js";
-import type { CandidateDiscoveryCache, DynamicMatchCache, EngineDeps } from "./engine-types.js";
-import type { matchRule } from "./matcher.js";
-import { sortCandidates } from "./ordering.js";
-import type { LoadedRule, MatchReason, RuleCandidate } from "./types.js";
-
-const MAX_DYNAMIC_MATCH_CACHE_ENTRIES = 4096;
-
-export function matchDynamicRuleCached(
-	cache: DynamicMatchCache,
-	projectRoot: string | null,
-	targetFile: string,
-	candidate: RuleCandidate,
-	loadedRule: LoadedRule,
-	matchRuleImpl: typeof matchRule,
-): MatchReason | null {
-	const cacheKey = dynamicMatchCacheKey(projectRoot, targetFile, candidate, loadedRule.contentHash);
-	if (cache.has(cacheKey)) {
-		const cachedReason = cache.get(cacheKey) ?? null;
-		cache.delete(cacheKey);
-		cache.set(cacheKey, cachedReason);
-		return cachedReason;
-	}
-
-	const matchResult = matchRuleImpl({
-		frontmatter: loadedRule.frontmatter,
-		isSingleFile: candidate.isSingleFile,
-		pathBases: pathBasesForTarget(projectRoot, targetFile, candidate),
-	});
-	const reason = matchResult.matched ? matchResult.reason : null;
-	setDynamicMatchCacheEntry(cache, cacheKey, reason);
-	return reason;
-}
-
-export function findSortedCandidatesCached(
-	cache: CandidateDiscoveryCache,
-	findCandidates: EngineDeps["findCandidates"],
-	options: Parameters<EngineDeps["findCandidates"]>[0],
-): RuleCandidate[] {
-	const cacheKey = candidateDiscoveryCacheKey(options);
-	const cached = cache.get(cacheKey);
-	if (cached !== undefined) {
-		return cached;
-	}
-
-	const candidates = sortCandidates(findCandidates(options));
-	cache.set(cacheKey, candidates);
-	return candidates;
-}
-
-function setDynamicMatchCacheEntry(cache: DynamicMatchCache, cacheKey: string, reason: MatchReason | null): void {
-	if (cache.size >= MAX_DYNAMIC_MATCH_CACHE_ENTRIES) {
-		const oldestCacheKey = cache.keys().next().value;
-		if (oldestCacheKey !== undefined) {
-			cache.delete(oldestCacheKey);
-		}
-	}
-	cache.set(cacheKey, reason);
-}
-
-function dynamicMatchCacheKey(
-	projectRoot: string | null,
-	targetFile: string,
-	candidate: RuleCandidate,
-	contentHash: string,
-): string {
-	return [
-		projectRoot ?? "",
-		toPosixPath(resolve(targetFile)),
-		candidate.realPath,
-		candidate.relativePath,
-		candidate.source,
-		candidate.isGlobal ? "global" : "project",
-		candidate.isSingleFile ? "single" : "multi",
-		String(candidate.distance),
-		contentHash,
-	].join("\0");
-}
-
-function candidateDiscoveryCacheKey(options: Parameters<EngineDeps["findCandidates"]>[0]): string {
-	return [
-		options.projectRoot ?? "",
-		options.targetFile === null ? "" : dirname(resolve(options.targetFile)),
-		...[...(options.disabledSources ?? [])].sort(),
-	].join("\0");
-}

package/packages/omo-codex/plugin/components/rules/src/rules/engine-dynamic-loader.ts

@@ -1,94 +0,0 @@
-import { findSortedCandidatesCached, matchDynamicRuleCached } from "./engine-dynamic-cache.js";
-import { loadCandidate, ruleDedupKey } from "./engine-loader.js";
-import { isSameOrChildPath } from "./engine-paths.js";
-import type { CandidateDiscoveryCache, DynamicMatchCache, EngineDeps, LoadedRuleContent } from "./engine-types.js";
-import { createRuleDiscoveryCache } from "./finder.js";
-import { matchRule } from "./matcher.js";
-import { sortCandidates } from "./ordering.js";
-import { disabledSourcesFromConfig } from "./sources.js";
-import type { LoadedRule, PiRulesConfig, RuleDiagnostic } from "./types.js";
-
-export function loadDynamicCandidates(
-	config: PiRulesConfig,
-	deps: EngineDeps,
-	cwd: string,
-	targetPaths: ReadonlyArray<string>,
-	dynamicMatchCache: DynamicMatchCache,
-): { rules: LoadedRule[]; diagnostics: RuleDiagnostic[] } {
-	const rules: LoadedRule[] = [];
-	const diagnostics: RuleDiagnostic[] = [];
-	const seenRules = new Set<string>();
-	const loadedRuleContent = new Map<string, LoadedRuleContent | null>();
-	const projectMembership = new Map<string, boolean>();
-	const disabledSources = disabledSourcesFromConfig(config);
-	const discoveryCache = createRuleDiscoveryCache();
-	const candidateDiscoveryCache: CandidateDiscoveryCache = new Map();
-	const cwdProjectRoot = deps.findProjectRoot(cwd);
-
-	for (const targetFile of uniqueStrings(targetPaths)) {
-		const projectRoot =
-			cwdProjectRoot !== null && isSameOrChildPath(targetFile, cwdProjectRoot)
-				? cwdProjectRoot
-				: deps.findProjectRoot(targetFile);
-		const findOptions: Parameters<EngineDeps["findCandidates"]>[0] = {
-			projectRoot,
-			targetFile,
-			cache: discoveryCache,
-		};
-		if (disabledSources !== undefined) {
-			findOptions.disabledSources = disabledSources;
-		}
-		const candidates = findSortedCandidatesCached(candidateDiscoveryCache, deps.findCandidates, findOptions);
-
-		for (const candidate of candidates) {
-			const loadedRule = loadCandidate(
-				candidate,
-				deps,
-				diagnostics,
-				projectRoot,
-				loadedRuleContent,
-				projectMembership,
-			);
-			if (loadedRule === null) {
-				continue;
-			}
-
-			const matchReason = matchDynamicRuleCached(
-				dynamicMatchCache,
-				projectRoot,
-				targetFile,
-				candidate,
-				loadedRule,
-				deps.matchRule ?? matchRule,
-			);
-
-			if (matchReason === null) {
-				continue;
-			}
-
-			const dedupKey = ruleDedupKey(loadedRule);
-			if (seenRules.has(dedupKey)) {
-				continue;
-			}
-
-			seenRules.add(dedupKey);
-			rules.push({ ...loadedRule, matchReason });
-		}
-	}
-
-	return { rules: sortCandidates(rules), diagnostics };
-}
-
-function uniqueStrings(values: ReadonlyArray<string>): string[] {
-	const uniqueValues: string[] = [];
-	const seenValues = new Set<string>();
-	for (const value of values) {
-		if (seenValues.has(value)) {
-			continue;
-		}
-
-		seenValues.add(value);
-		uniqueValues.push(value);
-	}
-	return uniqueValues;
-}