oh-my-opencode 4.10.0 → 4.11.0

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

@@ -1,75 +0,0 @@
-import { realpathSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { PROJECT_SINGLE_FILES } from "./constants.js";
-const ROOT_SINGLE_FILE_SOURCES = new Set(PROJECT_SINGLE_FILES.filter((source) => !source.includes("/")));
-export function isCandidateWithinProjectCached(candidate, projectRoot, projectMembership) {
-    if (projectMembership === undefined) {
-        return isCandidateWithinProject(candidate, projectRoot);
-    }
-    const cacheKey = `${projectRoot ?? ""}\0${candidate.realPath}`;
-    const cached = projectMembership.get(cacheKey);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const isWithinProject = isCandidateWithinProject(candidate, projectRoot);
-    projectMembership.set(cacheKey, isWithinProject);
-    return isWithinProject;
-}
-export function isSameOrChildPath(childPath, parentPath) {
-    const childRelativePath = relative(parentPath, resolve(childPath));
-    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
-}
-export function isRootSingleFile(candidate) {
-    return candidate.distance === 0 && candidate.isSingleFile && ROOT_SINGLE_FILE_SOURCES.has(candidate.source);
-}
-export function pathBasesForTarget(projectRoot, targetFile, candidate) {
-    const targetBasename = basename(targetFile);
-    if (projectRoot === null) {
-        return { projectRelative: targetBasename, basename: targetBasename };
-    }
-    const projectRelative = toPosixPath(relative(projectRoot, targetFile));
-    const scopeDirectory = scopeDirectoryForCandidate(projectRoot, candidate);
-    if (scopeDirectory === null) {
-        return { projectRelative, basename: targetBasename };
-    }
-    return {
-        projectRelative,
-        scopeRelative: toPosixPath(relative(scopeDirectory, targetFile)),
-        basename: targetBasename,
-    };
-}
-export function toPosixPath(path) {
-    return path.replaceAll("\\", "/");
-}
-function isCandidateWithinProject(candidate, projectRoot) {
-    if (candidate.isGlobal) {
-        return true;
-    }
-    if (projectRoot === null) {
-        return false;
-    }
-    const relativeRealPath = relative(realPathOrResolved(projectRoot), realPathOrResolved(candidate.realPath));
-    return relativeRealPath === "" || (!relativeRealPath.startsWith("..") && !isAbsolute(relativeRealPath));
-}
-function realPathOrResolved(path) {
-    try {
-        return realpathSync.native(path);
-    }
-    catch {
-        return resolve(path);
-    }
-}
-function scopeDirectoryForCandidate(projectRoot, candidate) {
-    if (candidate.isGlobal) {
-        return null;
-    }
-    if (candidate.isSingleFile) {
-        return dirname(candidate.path);
-    }
-    const sourceIndex = candidate.relativePath.indexOf(candidate.source);
-    if (sourceIndex === -1) {
-        return projectRoot;
-    }
-    const scopeRelativeDirectory = candidate.relativePath.slice(0, sourceIndex).replace(/\/$/, "");
-    return scopeRelativeDirectory.length === 0 ? projectRoot : join(projectRoot, scopeRelativeDirectory);
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-static-loader.d.ts

@@ -1,6 +0,0 @@
-import type { EngineDeps } from "./engine-types.js";
-import type { LoadedRule, RuleCandidate, RuleDiagnostic } from "./types.js";
-export declare function loadStaticCandidates(candidates: ReadonlyArray<RuleCandidate>, deps: EngineDeps, projectRoot: string | null): {
-    rules: LoadedRule[];
-    diagnostics: RuleDiagnostic[];
-};

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-static-loader.js

@@ -1,29 +0,0 @@
-import { loadCandidate, staticMatchReason } from "./engine-loader.js";
-import { isRootSingleFile } from "./engine-paths.js";
-import { sortCandidates } from "./ordering.js";
-export function loadStaticCandidates(candidates, deps, projectRoot) {
-    const rules = [];
-    const diagnostics = [];
-    let rootSingleFileSelected = false;
-    for (const candidate of sortCandidates(candidates)) {
-        if (isDedupedRootSingleFile(candidate, rootSingleFileSelected)) {
-            continue;
-        }
-        const loadedRule = loadCandidate(candidate, deps, diagnostics, projectRoot);
-        if (loadedRule === null) {
-            continue;
-        }
-        const matchReason = staticMatchReason(loadedRule);
-        if (matchReason === null) {
-            continue;
-        }
-        if (isRootSingleFile(candidate)) {
-            rootSingleFileSelected = true;
-        }
-        rules.push({ ...loadedRule, matchReason });
-    }
-    return { rules: sortCandidates(rules), diagnostics };
-}
-function isDedupedRootSingleFile(candidate, rootSingleFileSelected) {
-    return rootSingleFileSelected && isRootSingleFile(candidate);
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-types.d.ts

@@ -1,44 +0,0 @@
-import type { RuleDiscoveryCache } from "./finder.js";
-import type { matchRule } from "./matcher.js";
-import type { LoadedRule, MatchReason, PiRulesConfig, RuleCandidate, RuleDiagnostic, SessionState } from "./types.js";
-export interface LoadedRuleContent {
-    frontmatter: LoadedRule["frontmatter"];
-    body: string;
-    contentHash: string;
-    diagnostic?: string;
-}
-export type CandidateProjectMembership = Map<string, boolean>;
-export type CandidateDiscoveryCache = Map<string, RuleCandidate[]>;
-export type DynamicMatchCache = Map<string, MatchReason | null>;
-export interface EngineDeps {
-    findCandidates: (options: {
-        projectRoot: string | null;
-        targetFile: string | null;
-        homeDir?: string;
-        disabledSources?: ReadonlySet<string>;
-        skipUserHome?: boolean;
-        cache?: RuleDiscoveryCache;
-    }) => RuleCandidate[];
-    readFile: (path: string) => string | null;
-    findProjectRoot: (startPath: string) => string | null;
-    matchRule?: typeof matchRule;
-}
-export interface Engine {
-    state: SessionState;
-    config: PiRulesConfig;
-    loadStaticRules(cwd: string): {
-        rules: LoadedRule[];
-        diagnostics: RuleDiagnostic[];
-    };
-    loadDynamicRules(cwd: string, targetPaths: ReadonlyArray<string>): {
-        rules: LoadedRule[];
-        diagnostics: RuleDiagnostic[];
-    };
-    formatStatic(rules: ReadonlyArray<LoadedRule>): string;
-    formatDynamic(rules: ReadonlyArray<LoadedRule>, target: string): string;
-    resetSession(cwd?: string): void;
-    isStaticInjected(rule: LoadedRule): boolean;
-    isDynamicInjected(rule: LoadedRule): boolean;
-    markStaticInjected(rule: LoadedRule): boolean;
-    markDynamicInjected(rule: LoadedRule): boolean;
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,5 +0,0 @@
-import type { Engine, EngineDeps } from "./engine-types.js";
-import type { PiRulesConfig } from "./types.js";
-export type { Engine, EngineDeps } from "./engine-types.js";
-export declare function defaultConfig(): PiRulesConfig;
-export declare function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine;

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

@@ -1,85 +0,0 @@
-import { clearSession, createSessionState, isDynamicInjected as isDynamicInjectedInState, isStaticInjected as isStaticInjectedInState, markDynamicInjected as markDynamicInjectedInState, markStaticInjected as markStaticInjectedInState, } from "./cache.js";
-import { DEFAULT_DYNAMIC_MAX_RESULT_CHARS, DEFAULT_DYNAMIC_MAX_RULE_CHARS, DEFAULT_MAX_RESULT_CHARS, DEFAULT_MAX_RULE_CHARS, DEFAULT_POST_COMPACT_MAX_RESULT_CHARS, DEFAULT_POST_COMPACT_MAX_RULE_CHARS, DEFAULT_PROMPT_MAX_RESULT_CHARS, DEFAULT_PROMPT_MAX_RULE_CHARS, } from "./constants.js";
-import { loadDynamicCandidates } from "./engine-dynamic-loader.js";
-import { loadStaticCandidates } from "./engine-static-loader.js";
-import { formatDynamicBlock, formatStaticBlock } from "./formatter.js";
-import { disabledSourcesFromConfig } from "./sources.js";
-export function defaultConfig() {
-    return {
-        disabled: false,
-        mode: "both",
-        maxRuleChars: DEFAULT_MAX_RULE_CHARS,
-        maxResultChars: DEFAULT_MAX_RESULT_CHARS,
-        postCompactMaxRuleChars: DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
-        postCompactMaxResultChars: DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
-        dynamicMaxRuleChars: DEFAULT_DYNAMIC_MAX_RULE_CHARS,
-        dynamicMaxResultChars: DEFAULT_DYNAMIC_MAX_RESULT_CHARS,
-        promptMaxRuleChars: DEFAULT_PROMPT_MAX_RULE_CHARS,
-        promptMaxResultChars: DEFAULT_PROMPT_MAX_RESULT_CHARS,
-        enabledSources: "auto",
-    };
-}
-export function createEngine(config, deps) {
-    const state = createSessionState();
-    const dynamicMatchCache = new Map();
-    function loadStaticRules(cwd) {
-        state.cwd = cwd;
-        if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
-            return emptyLoadResult(state);
-        }
-        const projectRoot = deps.findProjectRoot(cwd);
-        const findOptions = {
-            projectRoot,
-            targetFile: null,
-        };
-        const disabledSources = disabledSourcesFromConfig(config);
-        if (disabledSources !== undefined) {
-            findOptions.disabledSources = disabledSources;
-        }
-        const candidates = deps.findCandidates(findOptions);
-        const result = loadStaticCandidates(candidates, deps, projectRoot);
-        storeLastLoad(state, result.rules, result.diagnostics);
-        return result;
-    }
-    function loadDynamicRules(cwd, targetPaths) {
-        state.cwd = cwd;
-        if (config.disabled || config.mode === "off" || config.mode === "static" || targetPaths.length === 0) {
-            return emptyLoadResult(state);
-        }
-        const result = loadDynamicCandidates(config, deps, cwd, targetPaths, dynamicMatchCache);
-        storeLastLoad(state, result.rules, result.diagnostics);
-        return result;
-    }
-    return {
-        state,
-        config,
-        loadStaticRules,
-        loadDynamicRules,
-        formatStatic: (rules) => formatStaticBlock(rules, { maxRuleChars: config.maxRuleChars, maxResultChars: config.maxResultChars }),
-        formatDynamic: (rules, target) => formatDynamicBlock(rules, target, {
-            maxRuleChars: config.maxRuleChars,
-            maxResultChars: config.maxResultChars,
-        }),
-        resetSession: (cwd) => {
-            clearSession(state);
-            dynamicMatchCache.clear();
-            if (cwd !== undefined) {
-                state.cwd = cwd;
-            }
-        },
-        isStaticInjected: (rule) => isStaticInjectedInState(state, rule),
-        isDynamicInjected: (rule) => isDynamicInjectedInState(state, rule),
-        markStaticInjected: (rule) => markStaticInjectedInState(state, rule),
-        markDynamicInjected: (rule) => markDynamicInjectedInState(state, rule),
-    };
-}
-function storeLastLoad(state, rules, diagnostics) {
-    state.loadedRules.length = 0;
-    state.loadedRules.push(...rules);
-    state.diagnostics.length = 0;
-    state.diagnostics.push(...diagnostics);
-}
-function emptyLoadResult(state) {
-    storeLastLoad(state, [], []);
-    return { rules: [], diagnostics: [] };
-}

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

@@ -1,6 +0,0 @@
-export declare class UnsupportedRuleSourceError extends Error {
-    constructor(message: string);
-}
-export declare class RuleFrontmatterParseError extends Error {
-    constructor(message: string);
-}

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

@@ -1,12 +0,0 @@
-export class UnsupportedRuleSourceError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "UnsupportedRuleSourceError";
-    }
-}
-export class RuleFrontmatterParseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "RuleFrontmatterParseError";
-    }
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/finder-cache.d.ts

@@ -1,14 +0,0 @@
-import { scanRuleFiles } from "./scanner.js";
-type ScannedRuleFiles = ReturnType<typeof scanRuleFiles>;
-interface SingleFileInfo {
-    readonly path: string;
-    readonly realPath: string;
-}
-export interface RuleDiscoveryCache {
-    readonly scannedRuleFiles: Map<string, ScannedRuleFiles>;
-    readonly singleFileInfo: Map<string, SingleFileInfo | null>;
-}
-export declare function createRuleDiscoveryCache(): RuleDiscoveryCache;
-export declare function scanRuleFilesCached(rootDir: string, cache: RuleDiscoveryCache | undefined): ScannedRuleFiles;
-export declare function singleFileInfoCached(filePath: string, cache: RuleDiscoveryCache | undefined): SingleFileInfo | null;
-export {};

package/packages/omo-codex/plugin/components/rules/dist/rules/finder-cache.js

@@ -1,51 +0,0 @@
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { scanRuleFiles } from "./scanner.js";
-export function createRuleDiscoveryCache() {
-    return { scannedRuleFiles: new Map(), singleFileInfo: new Map() };
-}
-export function scanRuleFilesCached(rootDir, cache) {
-    if (cache === undefined) {
-        return scanRuleFiles({ rootDir });
-    }
-    const cached = cache.scannedRuleFiles.get(rootDir);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const scannedFiles = scanRuleFiles({ rootDir });
-    cache.scannedRuleFiles.set(rootDir, scannedFiles);
-    return scannedFiles;
-}
-export function singleFileInfoCached(filePath, cache) {
-    if (cache === undefined) {
-        return readSingleFileInfo(filePath);
-    }
-    const cached = cache.singleFileInfo.get(filePath);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const fileInfo = readSingleFileInfo(filePath);
-    cache.singleFileInfo.set(filePath, fileInfo);
-    return fileInfo;
-}
-function readSingleFileInfo(filePath) {
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    try {
-        if (!statSync(filePath).isFile()) {
-            return null;
-        }
-        return { path: filePath, realPath: resolveRealPath(filePath) };
-    }
-    catch {
-        return null;
-    }
-}
-function resolveRealPath(filePath) {
-    try {
-        return realpathSync.native(filePath);
-    }
-    catch {
-        return filePath;
-    }
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/finder-paths.d.ts

@@ -1,6 +0,0 @@
-export interface WalkDirectory {
-    readonly directory: string;
-    readonly distance: number;
-}
-export declare function getWalkDirectories(projectRoot: string, targetFile: string | null): WalkDirectory[];
-export declare function toRelativePath(rootDirectory: string, filePath: string): string;

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

@@ -1,33 +0,0 @@
-import { dirname, posix, relative, resolve } from "node:path";
-export function getWalkDirectories(projectRoot, targetFile) {
-    if (targetFile === null) {
-        return [{ directory: projectRoot, distance: 0 }];
-    }
-    const startDirectory = dirname(resolve(targetFile));
-    if (!isSameOrChildPath(startDirectory, projectRoot)) {
-        return [{ directory: projectRoot, distance: 0 }];
-    }
-    const walkDirectories = [];
-    let currentDirectory = startDirectory;
-    let distance = 0;
-    while (true) {
-        walkDirectories.push({ directory: currentDirectory, distance });
-        if (currentDirectory === projectRoot) {
-            break;
-        }
-        const parentDirectory = dirname(currentDirectory);
-        if (parentDirectory === currentDirectory) {
-            break;
-        }
-        currentDirectory = parentDirectory;
-        distance += 1;
-    }
-    return walkDirectories;
-}
-export function toRelativePath(rootDirectory, filePath) {
-    return posix.normalize(relative(rootDirectory, filePath).replace(/\\/g, "/"));
-}
-function isSameOrChildPath(childPath, parentPath) {
-    const childRelativePath = relative(parentPath, childPath);
-    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !childRelativePath.startsWith("/"));
-}

package/packages/omo-codex/plugin/components/rules/dist/rules/finder-sources.d.ts

@@ -1,5 +0,0 @@
-import type { RuleSource } from "./types.js";
-export declare function toProjectRuleSource(parentDirectory: string, subDirectory: string): RuleSource;
-export declare function toProjectSingleFileSource(ruleFile: string): RuleSource;
-export declare function toUserHomeRuleSource(ruleSubdir: string): RuleSource;
-export declare function toUserHomeSingleFileSource(ruleFile: string): RuleSource;

package/packages/omo-codex/plugin/components/rules/dist/rules/finder-sources.js

@@ -1,40 +0,0 @@
-import { UnsupportedRuleSourceError } from "./errors.js";
-export function toProjectRuleSource(parentDirectory, subDirectory) {
-    const source = `${parentDirectory}/${subDirectory}`;
-    switch (source) {
-        case ".omo/rules":
-        case ".claude/rules":
-        case ".cursor/rules":
-        case ".github/instructions":
-            return source;
-        default:
-            throw new UnsupportedRuleSourceError(`Unsupported project rule source: ${source}`);
-    }
-}
-export function toProjectSingleFileSource(ruleFile) {
-    switch (ruleFile) {
-        case ".github/copilot-instructions.md":
-        case "CONTEXT.md":
-            return ruleFile;
-        default:
-            throw new UnsupportedRuleSourceError(`Unsupported project single-file source: ${ruleFile}`);
-    }
-}
-export function toUserHomeRuleSource(ruleSubdir) {
-    const source = `~/${ruleSubdir}`;
-    switch (source) {
-        case "~/.omo/rules":
-        case "~/.opencode/rules":
-        case "~/.claude/rules":
-            return source;
-        default:
-            throw new UnsupportedRuleSourceError(`Unsupported user-home rule source: ${source}`);
-    }
-}
-export function toUserHomeSingleFileSource(ruleFile) {
-    const source = `~/${ruleFile}`;
-    switch (source) {
-        default:
-            throw new UnsupportedRuleSourceError(`Unsupported user-home single-file source: ${source}`);
-    }
-}

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

@@ -1,28 +0,0 @@
-import { type RuleDiscoveryCache } from "./finder-cache.js";
-import type { RuleCandidate } from "./types.js";
-export type { RuleDiscoveryCache } from "./finder-cache.js";
-export { createRuleDiscoveryCache } from "./finder-cache.js";
-export interface FinderOptions {
-    /** Project root absolute path (use findProjectRoot to get this). */
-    projectRoot: string | null;
-    /** Target file path (used for distance calculation in dynamic injection mode). null for static mode. */
-    targetFile: string | null;
-    /** User home directory (default: os.homedir()). Injectable for tests. */
-    homeDir?: string;
-    /** Set of disabled sources to omit from discovery. Empty by default. */
-    disabledSources?: ReadonlySet<string>;
-    /** Whether to skip user-home rules. Default: false. */
-    skipUserHome?: boolean;
-    /** Plugin root directory. Defaults to PLUGIN_ROOT env or this package root. */
-    pluginRoot?: string;
-    platform?: NodeJS.Platform;
-    cache?: RuleDiscoveryCache;
-}
-interface PluginBundledFinderOptions {
-    readonly disabledSources?: ReadonlySet<string>;
-    readonly cache?: RuleDiscoveryCache;
-    readonly pluginRoot?: string;
-    readonly platform?: NodeJS.Platform;
-}
-export declare function findRuleCandidates(options: FinderOptions): RuleCandidate[];
-export declare function findPluginBundledCandidates(options?: PluginBundledFinderOptions): RuleCandidate[];

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

@@ -1,146 +0,0 @@
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { BUNDLED_RULE_SUBDIR, GLOBAL_DISTANCE, PROJECT_RULE_SUBDIRS, PROJECT_SINGLE_FILES, USER_HOME_RULE_SUBDIRS, USER_HOME_SINGLE_FILES, } from "./constants.js";
-import { scanRuleFilesCached, singleFileInfoCached } from "./finder-cache.js";
-import { getWalkDirectories, toRelativePath } from "./finder-paths.js";
-import { toProjectRuleSource, toProjectSingleFileSource, toUserHomeRuleSource, toUserHomeSingleFileSource, } from "./finder-sources.js";
-import { resolvePluginRulesRoot } from "./plugin-root.js";
-export { createRuleDiscoveryCache } from "./finder-cache.js";
-const WINDOWS_GIT_BASH_BUNDLED_RULE_PATH = "bundled-rules/windows-git-bash.md";
-export function findRuleCandidates(options) {
-    const skipUserHome = options.skipUserHome ?? false;
-    const disabledSources = options.disabledSources ?? new Set();
-    const candidates = [];
-    const homeDirectory = resolve(options.homeDir ?? homedir());
-    if (options.projectRoot !== null) {
-        candidates.push(...findProjectCandidates(options.projectRoot, options.targetFile, disabledSources, options.cache));
-    }
-    const pluginBundledOptions = {
-        disabledSources,
-        ...(options.cache === undefined ? {} : { cache: options.cache }),
-        ...(options.pluginRoot === undefined ? {} : { pluginRoot: options.pluginRoot }),
-        ...(options.platform === undefined ? {} : { platform: options.platform }),
-    };
-    candidates.push(...findPluginBundledCandidates(pluginBundledOptions));
-    if (!skipUserHome) {
-        candidates.push(...findUserHomeCandidates(homeDirectory, disabledSources, options.cache));
-    }
-    return candidates;
-}
-export function findPluginBundledCandidates(options = {}) {
-    if (options.disabledSources?.has("plugin-bundled") === true) {
-        return [];
-    }
-    const pluginRoot = resolvePluginRulesRoot(options.pluginRoot);
-    const ruleDirectory = join(pluginRoot, BUNDLED_RULE_SUBDIR);
-    const platform = options.platform ?? process.platform;
-    const candidates = [];
-    for (const scannedFile of scanRuleFilesCached(ruleDirectory, options.cache)) {
-        const candidate = {
-            path: scannedFile.path,
-            realPath: scannedFile.realPath,
-            source: "plugin-bundled",
-            distance: GLOBAL_DISTANCE,
-            isGlobal: true,
-            isSingleFile: false,
-            relativePath: toRelativePath(pluginRoot, scannedFile.path),
-        };
-        if (isPluginBundledCandidateEnabled(candidate, platform)) {
-            candidates.push(candidate);
-        }
-    }
-    return candidates;
-}
-function isPluginBundledCandidateEnabled(candidate, platform) {
-    return candidate.relativePath !== WINDOWS_GIT_BASH_BUNDLED_RULE_PATH || platform === "win32";
-}
-function findProjectCandidates(projectRoot, targetFile, disabledSources, cache) {
-    const rootDirectory = resolve(projectRoot);
-    const walkDirectories = getWalkDirectories(rootDirectory, targetFile);
-    const candidates = [];
-    for (const walkDirectory of walkDirectories) {
-        for (const [parentDirectory, subDirectory] of PROJECT_RULE_SUBDIRS) {
-            const source = toProjectRuleSource(parentDirectory, subDirectory);
-            if (disabledSources.has(source)) {
-                continue;
-            }
-            const ruleDirectory = join(walkDirectory.directory, parentDirectory, subDirectory);
-            for (const scannedFile of scanRuleFilesCached(ruleDirectory, cache)) {
-                candidates.push({
-                    path: scannedFile.path,
-                    realPath: scannedFile.realPath,
-                    source,
-                    distance: targetFile === null ? 0 : walkDirectory.distance,
-                    isGlobal: false,
-                    isSingleFile: false,
-                    relativePath: toRelativePath(rootDirectory, scannedFile.path),
-                });
-            }
-        }
-    }
-    for (const walkDirectory of walkDirectories) {
-        for (const ruleFile of PROJECT_SINGLE_FILES) {
-            const source = toProjectSingleFileSource(ruleFile);
-            if (disabledSources.has(source)) {
-                continue;
-            }
-            const filePath = join(walkDirectory.directory, ruleFile);
-            const fileInfo = singleFileInfoCached(filePath, cache);
-            if (fileInfo === null) {
-                continue;
-            }
-            candidates.push({
-                path: fileInfo.path,
-                realPath: fileInfo.realPath,
-                source,
-                distance: targetFile === null ? 0 : walkDirectory.distance,
-                isGlobal: false,
-                isSingleFile: true,
-                relativePath: toRelativePath(rootDirectory, filePath),
-            });
-        }
-    }
-    return candidates;
-}
-function findUserHomeCandidates(homeDirectory, disabledSources, cache) {
-    const candidates = [];
-    for (const ruleSubdir of USER_HOME_RULE_SUBDIRS) {
-        const source = toUserHomeRuleSource(ruleSubdir);
-        if (disabledSources.has(source)) {
-            continue;
-        }
-        const ruleDirectory = join(homeDirectory, ruleSubdir);
-        for (const scannedFile of scanRuleFilesCached(ruleDirectory, cache)) {
-            candidates.push({
-                path: scannedFile.path,
-                realPath: scannedFile.realPath,
-                source,
-                distance: GLOBAL_DISTANCE,
-                isGlobal: true,
-                isSingleFile: false,
-                relativePath: toRelativePath(homeDirectory, scannedFile.path),
-            });
-        }
-    }
-    for (const ruleFile of USER_HOME_SINGLE_FILES) {
-        const source = toUserHomeSingleFileSource(ruleFile);
-        if (disabledSources.has(source)) {
-            continue;
-        }
-        const filePath = join(homeDirectory, ruleFile);
-        const fileInfo = singleFileInfoCached(filePath, cache);
-        if (fileInfo === null) {
-            continue;
-        }
-        candidates.push({
-            path: fileInfo.path,
-            realPath: fileInfo.realPath,
-            source,
-            distance: GLOBAL_DISTANCE,
-            isGlobal: true,
-            isSingleFile: true,
-            relativePath: toRelativePath(homeDirectory, filePath),
-        });
-    }
-    return candidates;
-}

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

@@ -1,7 +0,0 @@
-import type { LoadedRule } from "./types.js";
-export interface FormatOptions {
-    maxRuleChars: number;
-    maxResultChars: number;
-}
-export declare function formatStaticBlock(rules: ReadonlyArray<LoadedRule>, options: FormatOptions): string;
-export declare function formatDynamicBlock(rules: ReadonlyArray<LoadedRule>, targetRelativePath: string, options: FormatOptions): string;