@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/rules/dist/rules/matcher.js

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import picomatch from "picomatch";
+const compiledPatternSets = new Map();
+export function matchRule(input) {
+    if (input.isSingleFile) {
+        return { matched: true, reason: "single-file" };
+    }
+    if (input.frontmatter.alwaysApply === true) {
+        return { matched: true, reason: "alwaysApply" };
+    }
+    const patterns = normalizeGlobs(input.frontmatter);
+    if (patterns.length === 0) {
+        return noMatch();
+    }
+    const pathBases = normalizedPathBases(input.pathBases);
+    const { positivePatterns, negativeMatchers } = compiledPatternSetFor(patterns);
+    for (const { pattern, isMatch } of positivePatterns) {
+        for (const pathBase of pathBases) {
+            if (!isMatch(pathBase)) {
+                continue;
+            }
+            if (isExcluded(pathBase, negativeMatchers)) {
+                return noMatch();
+            }
+            return { matched: true, reason: { kind: "glob", pattern } };
+        }
+    }
+    return noMatch();
+}
+export function normalizeGlobs(frontmatter) {
+    const patterns = [
+        ...normalizePatternList(frontmatter.globs),
+        ...normalizePatternList(frontmatter.paths),
+        ...normalizePatternList(frontmatter.applyTo),
+    ];
+    return [...new Set(patterns.map(normalizePath))];
+}
+export function hashContent(body) {
+    return createHash("sha256").update(body).digest("hex");
+}
+function normalizePatternList(patterns) {
+    if (patterns === undefined) {
+        return [];
+    }
+    return Array.isArray(patterns) ? patterns : [patterns];
+}
+function normalizePath(path) {
+    return path.replaceAll("\\", "/");
+}
+function normalizedPathBases(pathBases) {
+    const normalizedBases = [normalizePath(pathBases.projectRelative)];
+    if (pathBases.scopeRelative !== undefined) {
+        normalizedBases.push(normalizePath(pathBases.scopeRelative));
+    }
+    normalizedBases.push(normalizePath(pathBases.basename));
+    return normalizedBases;
+}
+function compiledPatternSetFor(patterns) {
+    const cacheKey = JSON.stringify(patterns);
+    const cached = compiledPatternSets.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const compiled = compilePatternSet(patterns);
+    compiledPatternSets.set(cacheKey, compiled);
+    return compiled;
+}
+function compilePatternSet(patterns) {
+    const positivePatterns = [];
+    const negativeMatchers = [];
+    for (const pattern of patterns) {
+        if (pattern.startsWith("!")) {
+            negativeMatchers.push(createGlobMatcher(pattern.slice(1)));
+            continue;
+        }
+        positivePatterns.push({ pattern, isMatch: createGlobMatcher(pattern) });
+    }
+    return { positivePatterns, negativeMatchers };
+}
+function createGlobMatcher(pattern) {
+    return picomatch(normalizePath(pattern), { bash: true, dot: true });
+}
+function isExcluded(pathBase, negativeMatchers) {
+    for (const isMatch of negativeMatchers) {
+        if (isMatch(pathBase)) {
+            return true;
+        }
+    }
+    return false;
+}
+function noMatch() {
+    return { matched: false, reason: { kind: "no-match" } };
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/ordering.d.ts

@@ -0,0 +1,3 @@
+import type { RuleCandidate } from "./types.js";
+export declare function sortCandidates<T extends RuleCandidate>(candidates: ReadonlyArray<T>): T[];
+export declare function compareCandidates(a: RuleCandidate, b: RuleCandidate): number;

package/marketplace/plugins/litcodex/components/rules/dist/rules/ordering.js

@@ -0,0 +1,27 @@
+import { SOURCE_PRIORITY } from "./constants.js";
+export function sortCandidates(candidates) {
+    return candidates
+        .map((candidate, index) => ({ candidate, index }))
+        .sort((left, right) => compareCandidates(left.candidate, right.candidate) || left.index - right.index)
+        .map(({ candidate }) => candidate);
+}
+export function compareCandidates(a, b) {
+    return (compareBoolean(a.isGlobal, b.isGlobal) ||
+        compareNumber(a.distance, b.distance) ||
+        compareNumber(SOURCE_PRIORITY.get(a.source) ?? Infinity, SOURCE_PRIORITY.get(b.source) ?? Infinity) ||
+        compareString(a.relativePath, b.relativePath) ||
+        compareString(a.realPath, b.realPath));
+}
+function compareBoolean(a, b) {
+    return Number(a) - Number(b);
+}
+function compareNumber(a, b) {
+    return a - b;
+}
+function compareString(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser-frontmatter.d.ts

@@ -0,0 +1,7 @@
+export type ClosingDelimiter = {
+    readonly start: number;
+    readonly bodyStart: number;
+};
+export declare function stripBom(content: string): string;
+export declare function getOpeningDelimiterLength(content: string): number;
+export declare function findClosingDelimiter(content: string, openingLength: number): ClosingDelimiter | null;

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser-frontmatter.js

@@ -0,0 +1,30 @@
+const FRONTMATTER_OPENING = "---\n";
+const FRONTMATTER_OPENING_CRLF = "---\r\n";
+export function stripBom(content) {
+    return content.startsWith("") ? content.slice(1) : content;
+}
+export function getOpeningDelimiterLength(content) {
+    if (content.startsWith(FRONTMATTER_OPENING_CRLF))
+        return FRONTMATTER_OPENING_CRLF.length;
+    if (content.startsWith(FRONTMATTER_OPENING))
+        return FRONTMATTER_OPENING.length;
+    return 0;
+}
+export function findClosingDelimiter(content, openingLength) {
+    let lineStart = openingLength;
+    while (lineStart <= content.length) {
+        const nextNewline = content.indexOf("\n", lineStart);
+        const lineEnd = nextNewline === -1 ? content.length : nextNewline;
+        const line = content.slice(lineStart, lineEnd).replace(/\r$/, "");
+        if (line === "---") {
+            return {
+                start: lineStart,
+                bodyStart: nextNewline === -1 ? content.length : nextNewline + 1,
+            };
+        }
+        if (nextNewline === -1)
+            break;
+        lineStart = nextNewline + 1;
+    }
+    return null;
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser-yaml.d.ts

@@ -0,0 +1,2 @@
+import type { RuleFrontmatter } from "./types.js";
+export declare function parseYamlFrontmatter(yamlContent: string): RuleFrontmatter;

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser-yaml.js

@@ -0,0 +1,237 @@
+import { RuleFrontmatterParseError } from "./errors.js";
+export function parseYamlFrontmatter(yamlContent) {
+    const lines = yamlContent.replace(/\r\n/g, "\n").split("\n");
+    const frontmatter = {};
+    const globValues = [];
+    const seenGlobs = new Set();
+    let lineIndex = 0;
+    while (lineIndex < lines.length) {
+        const rawLine = lines[lineIndex];
+        if (rawLine === undefined)
+            break;
+        const line = stripComment(rawLine).trim();
+        if (line.length === 0) {
+            lineIndex += 1;
+            continue;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1) {
+            throw new RuleFrontmatterParseError(`Expected key-value pair on line ${lineIndex + 1}`);
+        }
+        const key = line.slice(0, colonIndex).trim();
+        const rawValue = line.slice(colonIndex + 1).trim();
+        if (key === "description") {
+            frontmatter.description = parseStringValue(rawValue);
+            lineIndex += 1;
+            continue;
+        }
+        if (key === "alwaysApply") {
+            frontmatter.alwaysApply = parseBooleanValue(rawValue, lineIndex + 1);
+            lineIndex += 1;
+            continue;
+        }
+        if (key === "globs" || key === "paths" || key === "applyTo") {
+            const parsed = parseGlobValue(rawValue, lines, lineIndex);
+            for (const glob of parsed.values) {
+                if (!seenGlobs.has(glob)) {
+                    seenGlobs.add(glob);
+                    globValues.push(glob);
+                }
+            }
+            lineIndex += parsed.consumed;
+            continue;
+        }
+        lineIndex += 1;
+    }
+    const singleGlob = globValues[0];
+    if (globValues.length === 1 && singleGlob !== undefined) {
+        frontmatter.globs = singleGlob;
+    }
+    else if (globValues.length > 1) {
+        frontmatter.globs = globValues;
+    }
+    return frontmatter;
+}
+function parseBooleanValue(value, lineNumber) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    throw new RuleFrontmatterParseError(`Expected boolean on line ${lineNumber}`);
+}
+function parseGlobValue(rawValue, lines, lineIndex) {
+    if (rawValue.startsWith("[")) {
+        return { values: parseInlineArray(rawValue), consumed: 1 };
+    }
+    if (rawValue.length === 0) {
+        return parseMultilineArray(lines, lineIndex);
+    }
+    const quotedScalar = isQuotedScalar(rawValue);
+    const value = parseStringValue(rawValue);
+    if (!quotedScalar && value.includes(",")) {
+        return {
+            values: value
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean),
+            consumed: 1,
+        };
+    }
+    return { values: [value], consumed: 1 };
+}
+function isQuotedScalar(value) {
+    return value.startsWith('"') || value.startsWith("'");
+}
+function parseMultilineArray(lines, lineIndex) {
+    const values = [];
+    let consumed = 1;
+    for (let index = lineIndex + 1; index < lines.length; index += 1) {
+        const rawLine = lines[index];
+        if (rawLine === undefined)
+            break;
+        const lineWithoutComment = stripComment(rawLine);
+        if (lineWithoutComment.trim().length === 0) {
+            consumed += 1;
+            continue;
+        }
+        const arrayItem = lineWithoutComment.match(/^\s+-\s*(.*)$/);
+        if (arrayItem === null)
+            break;
+        values.push(parseStringValue(arrayItem[1] ?? ""));
+        consumed += 1;
+    }
+    return { values: values.filter(Boolean), consumed };
+}
+function parseInlineArray(value) {
+    const closingBracketIndex = findClosingBracket(value);
+    if (closingBracketIndex === -1) {
+        throw new RuleFrontmatterParseError("Unclosed inline array");
+    }
+    const trailing = value.slice(closingBracketIndex + 1).trim();
+    if (trailing.length > 0) {
+        throw new RuleFrontmatterParseError("Unexpected content after inline array");
+    }
+    const content = value.slice(1, closingBracketIndex).trim();
+    if (content.length === 0)
+        return [];
+    return splitCommaSeparated(content).map(parseStringValue).filter(Boolean);
+}
+function findClosingBracket(value) {
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character === undefined)
+            continue;
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote !== null && character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            if (quote === null)
+                quote = character;
+            else if (quote === character)
+                quote = null;
+            continue;
+        }
+        if (quote === null && character === "]")
+            return index;
+    }
+    return -1;
+}
+function splitCommaSeparated(value) {
+    const values = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character === undefined)
+            continue;
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (quote !== null && character === "\\") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            if (quote === null)
+                quote = character;
+            else if (quote === character)
+                quote = null;
+            current += character;
+            continue;
+        }
+        if (quote === null && character === ",") {
+            values.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (quote !== null) {
+        throw new RuleFrontmatterParseError("Unclosed quoted value");
+    }
+    values.push(current.trim());
+    return values.filter(Boolean);
+}
+function parseStringValue(value) {
+    if (value.length === 0)
+        return "";
+    if (value.startsWith('"'))
+        return parseJsonString(value);
+    if (value.startsWith("'") && value.endsWith("'"))
+        return value.slice(1, -1);
+    if (value.startsWith("'"))
+        throw new RuleFrontmatterParseError("Unclosed quoted value");
+    return value;
+}
+function parseJsonString(value) {
+    try {
+        const parsedValue = JSON.parse(value);
+        if (typeof parsedValue !== "string") {
+            throw new RuleFrontmatterParseError("Expected JSON-quoted string");
+        }
+        return parsedValue;
+    }
+    catch (error) {
+        if (error instanceof RuleFrontmatterParseError)
+            throw error;
+        throw new RuleFrontmatterParseError("Invalid JSON-quoted string");
+    }
+}
+function stripComment(line) {
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (character === undefined)
+            continue;
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote !== null && character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            if (quote === null)
+                quote = character;
+            else if (quote === character)
+                quote = null;
+            continue;
+        }
+        if (quote === null && character === "#")
+            return line.slice(0, index);
+    }
+    return line;
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedRule } from "./types.js";
+/** Parse markdown rule content and extract the supported YAML frontmatter subset. */
+export declare function parseRule(content: string): ParsedRule;

package/marketplace/plugins/litcodex/components/rules/dist/rules/parser.js

@@ -0,0 +1,31 @@
+import { findClosingDelimiter, getOpeningDelimiterLength, stripBom } from "./parser-frontmatter.js";
+import { parseYamlFrontmatter } from "./parser-yaml.js";
+/** Parse markdown rule content and extract the supported YAML frontmatter subset. */
+export function parseRule(content) {
+    const normalizedContent = stripBom(content);
+    const openingLength = getOpeningDelimiterLength(normalizedContent);
+    if (openingLength === 0) {
+        return { frontmatter: {}, body: normalizedContent };
+    }
+    const closingDelimiter = findClosingDelimiter(normalizedContent, openingLength);
+    if (closingDelimiter === null) {
+        return {
+            frontmatter: {},
+            body: normalizedContent,
+            diagnostic: "Missing closing frontmatter delimiter",
+        };
+    }
+    const yamlContent = normalizedContent.slice(openingLength, closingDelimiter.start);
+    const body = normalizedContent.slice(closingDelimiter.bodyStart);
+    try {
+        return { frontmatter: parseYamlFrontmatter(yamlContent), body };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid YAML frontmatter";
+        return {
+            frontmatter: {},
+            body: normalizedContent,
+            diagnostic: `Malformed frontmatter: ${message}`,
+        };
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/plugin-root.d.ts

@@ -0,0 +1 @@
+export declare function resolvePluginRulesRoot(pluginRoot: string | undefined, moduleUrl?: string): string;

package/marketplace/plugins/litcodex/components/rules/dist/rules/plugin-root.js

@@ -0,0 +1,48 @@
+import { statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const PLUGIN_MANIFEST_PATH = join(".codex-plugin", "plugin.json");
+export function resolvePluginRulesRoot(pluginRoot, moduleUrl = import.meta.url) {
+    const configuredRoot = pluginRoot ?? process.env["PLUGIN_ROOT"];
+    if (configuredRoot !== undefined && configuredRoot.trim().length > 0) {
+        return resolveRulesComponentRoot(resolve(configuredRoot));
+    }
+    const discoveredRoot = findNearestPluginRoot(dirname(fileURLToPath(moduleUrl)));
+    if (discoveredRoot !== null) {
+        return resolveRulesComponentRoot(discoveredRoot);
+    }
+    return fileURLToPath(new URL("../../..", moduleUrl));
+}
+function findNearestPluginRoot(startDirectory) {
+    let currentDirectory = resolve(startDirectory);
+    while (true) {
+        if (isFile(join(currentDirectory, PLUGIN_MANIFEST_PATH))) {
+            return currentDirectory;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return null;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+function resolveRulesComponentRoot(pluginRoot) {
+    const componentRoot = join(pluginRoot, "components", "rules");
+    return isDirectory(componentRoot) ? componentRoot : pluginRoot;
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/project-root.d.ts

@@ -0,0 +1 @@
+export declare function findProjectRoot(startPath: string, markers?: ReadonlyArray<string>): string | null;

package/marketplace/plugins/litcodex/components/rules/dist/rules/project-root.js

@@ -0,0 +1,23 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { PROJECT_MARKERS } from "./constants.js";
+export function findProjectRoot(startPath, markers = PROJECT_MARKERS) {
+    const resolvedStartPath = resolve(startPath);
+    if (!existsSync(resolvedStartPath)) {
+        return null;
+    }
+    const startStats = statSync(resolvedStartPath);
+    let currentDirectory = startStats.isDirectory() ? resolvedStartPath : dirname(resolvedStartPath);
+    const filesystemRoot = resolve("/");
+    while (true) {
+        for (const marker of markers) {
+            if (existsSync(join(currentDirectory, marker))) {
+                return currentDirectory;
+            }
+        }
+        if (currentDirectory === filesystemRoot) {
+            return null;
+        }
+        currentDirectory = dirname(currentDirectory);
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/scanner.d.ts

@@ -0,0 +1,14 @@
+export interface ScanOptions {
+    rootDir: string;
+    excludedDirs?: ReadonlyArray<string>;
+    /** Maximum recursion depth. Default: 10 */
+    maxDepth?: number;
+    maxFiles?: number;
+}
+export interface ScannedFile {
+    /** Absolute path as encountered (may be a symlink). */
+    path: string;
+    /** Real (resolved) path; same as path if not a symlink. */
+    realPath: string;
+}
+export declare function scanRuleFiles(options: ScanOptions): ScannedFile[];

package/marketplace/plugins/litcodex/components/rules/dist/rules/scanner.js

@@ -0,0 +1,111 @@
+import { existsSync, lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { DEFAULT_MAX_SCAN_FILES, RULE_FILE_EXTENSIONS, SCANNER_EXCLUDED_DIRS } from "./constants.js";
+export function scanRuleFiles(options) {
+    const rootPath = toAbsolutePath(options.rootDir);
+    if (!existsSync(rootPath)) {
+        return [];
+    }
+    let rootStats;
+    try {
+        rootStats = statSync(rootPath);
+    }
+    catch {
+        return [];
+    }
+    if (!rootStats.isDirectory()) {
+        return [];
+    }
+    const results = [];
+    const visitedDirectories = new Set();
+    const excludedDirs = new Set(options.excludedDirs ?? SCANNER_EXCLUDED_DIRS);
+    const maxDepth = options.maxDepth ?? 10;
+    const maxFiles = normalizeMaxFiles(options.maxFiles);
+    scanDirectory(rootPath, 0, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+    return results;
+}
+function normalizeMaxFiles(maxFiles) {
+    const value = maxFiles ?? DEFAULT_MAX_SCAN_FILES;
+    if (!Number.isFinite(value) || value < 0)
+        return DEFAULT_MAX_SCAN_FILES;
+    return Math.floor(value);
+}
+function toAbsolutePath(filePath) {
+    return isAbsolute(filePath) ? filePath : resolve(filePath);
+}
+function scanDirectory(directoryPath, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results) {
+    if (results.length >= maxFiles) {
+        return;
+    }
+    let realDirectoryPath;
+    try {
+        realDirectoryPath = realpathSync.native(directoryPath);
+    }
+    catch {
+        return;
+    }
+    if (visitedDirectories.has(realDirectoryPath)) {
+        return;
+    }
+    visitedDirectories.add(realDirectoryPath);
+    let entries;
+    try {
+        entries = readdirSync(directoryPath, { withFileTypes: true }).sort((leftEntry, rightEntry) => leftEntry.name.localeCompare(rightEntry.name));
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxFiles) {
+            return;
+        }
+        const entryPath = join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            if (!excludedDirs.has(entry.name) && depth < maxDepth) {
+                scanDirectory(entryPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+            }
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            scanSymbolicLink(entryPath, entry.name, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+            continue;
+        }
+        if (entry.isFile() && isRuleFile(entry.name)) {
+            results.push({ path: entryPath, realPath: resolveRealPath(entryPath) });
+        }
+    }
+}
+function scanSymbolicLink(linkPath, linkName, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results) {
+    if (results.length >= maxFiles) {
+        return;
+    }
+    let targetStats;
+    try {
+        targetStats = statSync(linkPath);
+    }
+    catch {
+        return;
+    }
+    if (targetStats.isDirectory()) {
+        if (!excludedDirs.has(linkName) && depth < maxDepth) {
+            scanDirectory(linkPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+        }
+        return;
+    }
+    if (targetStats.isFile() && isRuleFile(linkName)) {
+        results.push({ path: linkPath, realPath: resolveRealPath(linkPath) });
+    }
+}
+function isRuleFile(fileName) {
+    return RULE_FILE_EXTENSIONS.some((extension) => fileName.endsWith(extension));
+}
+function resolveRealPath(filePath) {
+    try {
+        const realPath = realpathSync.native(filePath);
+        const fileStats = lstatSync(filePath);
+        return fileStats.isSymbolicLink() ? realPath : filePath;
+    }
+    catch {
+        return filePath;
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/sources.d.ts

@@ -0,0 +1,3 @@
+import type { PiRulesConfig } from "./types.js";
+export declare const DEFAULT_AUTO_DISABLED_SOURCES: readonly string[];
+export declare function disabledSourcesFromConfig(config: PiRulesConfig): ReadonlySet<string> | undefined;

package/marketplace/plugins/litcodex/components/rules/dist/rules/sources.js

@@ -0,0 +1,9 @@
+import { SOURCE_PRIORITY } from "./constants.js";
+export const DEFAULT_AUTO_DISABLED_SOURCES = ["AGENTS.md", "~/.claude/rules", "~/.claude/CLAUDE.md"];
+export function disabledSourcesFromConfig(config) {
+    if (config.enabledSources === "auto") {
+        return new Set(DEFAULT_AUTO_DISABLED_SOURCES);
+    }
+    const enabledSources = new Set(config.enabledSources);
+    return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/truncator.d.ts

@@ -0,0 +1,19 @@
+import type { TruncationResult } from "./types.js";
+type BudgetRule = {
+    body: string;
+    relativePath: string;
+};
+type BudgetResult = BudgetRule & {
+    truncated: boolean;
+};
+export declare function truncationNotice(relativePath: string): string;
+export declare function isNeverTruncatedRule(relativePath: string): boolean;
+export declare function truncateRule(body: string, options: {
+    maxChars: number;
+    relativePath: string;
+}): TruncationResult;
+export declare function truncateBudget(input: {
+    rules: ReadonlyArray<BudgetRule>;
+    maxResultChars: number;
+}): BudgetResult[];
+export {};