oh-my-opencode 4.8.1 → 4.9.1

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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,7 @@
+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;

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

@@ -0,0 +1,112 @@
+import { isNeverTruncatedRule, truncateBudget, truncateRule } from "./truncator.js";
+function formatRule(rule) {
+    const body = normalizeRuleBody(rule.body);
+    if (body.length === 0) {
+        return `Instructions from: ${rule.path}`;
+    }
+    return `Instructions from: ${rule.path}\n\n${body}`;
+}
+function truncateRules(rules, options) {
+    const perRuleNormalized = rules.map((rule) => ({
+        path: rule.path,
+        relativePath: rule.relativePath,
+        body: normalizeRuleBody(rule.body),
+        source: rule.source,
+    }));
+    const perRuleResultChars = Math.floor(options.maxResultChars / Math.max(1, perRuleNormalized.length));
+    const perRuleBudgeted = perRuleNormalized.map((rule) => ({
+        path: rule.path,
+        relativePath: rule.relativePath,
+        body: isNeverTruncatedRule(rule.relativePath)
+            ? rule.body
+            : truncateRule(rule.body, {
+                maxChars: Math.min(options.maxRuleChars, perRuleResultChars),
+                relativePath: rule.relativePath,
+            }).body,
+    }));
+    const budgetedRules = truncateBudget({
+        rules: perRuleBudgeted.map((rule) => ({ body: rule.body, relativePath: rule.relativePath })),
+        maxResultChars: options.maxResultChars,
+    });
+    const truncatedRules = [];
+    for (let index = 0; index < budgetedRules.length; index += 1) {
+        const sourceRule = perRuleBudgeted[index];
+        const budgetedRule = budgetedRules[index];
+        if (sourceRule === undefined || budgetedRule === undefined) {
+            continue;
+        }
+        truncatedRules.push({
+            path: sourceRule.path,
+            relativePath: budgetedRule.relativePath,
+            body: budgetedRule.body,
+        });
+    }
+    return truncatedRules;
+}
+export function formatStaticBlock(rules, options) {
+    if (rules.length === 0) {
+        return "";
+    }
+    if (options.maxResultChars <= 0) {
+        return "";
+    }
+    const orderedRules = orderStaticRules(uniqueRulesByBody(rules));
+    return ["## Project Instructions", "", truncateRules(orderedRules, options).map(formatRule).join("\n\n")].join("\n");
+}
+function orderStaticRules(rules) {
+    const hephaestusRules = [];
+    const otherRules = [];
+    for (const rule of rules) {
+        if (isHephaestusRule(rule)) {
+            hephaestusRules.push(rule);
+            continue;
+        }
+        otherRules.push(rule);
+    }
+    return [...hephaestusRules, ...otherRules];
+}
+function isHephaestusRule(rule) {
+    return displayFilename(rule).toLowerCase() === "hephaestus.md";
+}
+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;
+}
+function uniqueRulesByBody(rules) {
+    const uniqueRules = [];
+    const seenBodies = new Set();
+    const userDescriptions = new Set();
+    for (const rule of rules) {
+        const descriptionKey = rule.frontmatter.description?.trim();
+        if (rule.source === "plugin-bundled" && descriptionKey !== undefined && userDescriptions.has(descriptionKey)) {
+            continue;
+        }
+        const bodyKey = normalizeRuleBody(rule.body);
+        if (seenBodies.has(bodyKey)) {
+            continue;
+        }
+        seenBodies.add(bodyKey);
+        if (descriptionKey !== undefined && rule.source !== "plugin-bundled") {
+            userDescriptions.add(descriptionKey);
+        }
+        uniqueRules.push(rule);
+    }
+    return uniqueRules;
+}
+export function formatDynamicBlock(rules, targetRelativePath, options) {
+    if (rules.length === 0) {
+        return "";
+    }
+    return [
+        `Additional project instructions matched for ${targetRelativePath}:`,
+        "",
+        truncateRules(rules, options).map(formatRule).join("\n\n"),
+    ].join("\n");
+}
+function normalizeRuleBody(body) {
+    return body.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}

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

@@ -0,0 +1,18 @@
+import type { MatchReason, RuleFrontmatter } from "./types.js";
+export interface MatcherInput {
+    frontmatter: RuleFrontmatter;
+    isSingleFile: boolean;
+    /** Path bases to try matching against (POSIX-normalized). */
+    pathBases: {
+        projectRelative: string;
+        scopeRelative?: string;
+        basename: string;
+    };
+}
+export interface MatchResult {
+    matched: boolean;
+    reason: MatchReason;
+}
+export declare function matchRule(input: MatcherInput): MatchResult;
+export declare function normalizeGlobs(frontmatter: RuleFrontmatter): string[];
+export declare function hashContent(body: string): string;

package/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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;