oh-my-opencode 4.5.1 → 4.5.12

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

@@ -0,0 +1,50 @@
+import { UnsupportedRuleSourceError } from "./errors.js";
+import type { RuleSource } from "./types.js";
+
+export function toProjectRuleSource(parentDirectory: string, subDirectory: string): RuleSource {
+	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: string): RuleSource {
+	switch (ruleFile) {
+		case ".github/copilot-instructions.md":
+		case "AGENTS.md":
+		case "CLAUDE.md":
+		case "CONTEXT.md":
+			return ruleFile;
+		default:
+			throw new UnsupportedRuleSourceError(`Unsupported project single-file source: ${ruleFile}`);
+	}
+}
+
+export function toUserHomeRuleSource(ruleSubdir: string): RuleSource {
+	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: string): RuleSource {
+	const source = `~/${ruleFile}`;
+	switch (source) {
+		case "~/.config/opencode/AGENTS.md":
+		case "~/.claude/CLAUDE.md":
+			return source;
+		default:
+			throw new UnsupportedRuleSourceError(`Unsupported user-home single-file source: ${source}`);
+	}
+}

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

@@ -0,0 +1,207 @@
+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 { type RuleDiscoveryCache, 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";
+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;
+	cache?: RuleDiscoveryCache;
+}
+
+interface PluginBundledFinderOptions {
+	readonly disabledSources?: ReadonlySet<string>;
+	readonly cache?: RuleDiscoveryCache;
+	readonly pluginRoot?: string;
+}
+
+export function findRuleCandidates(options: FinderOptions): RuleCandidate[] {
+	const skipUserHome = options.skipUserHome ?? false;
+	const disabledSources = options.disabledSources ?? new Set<string>();
+	const candidates: RuleCandidate[] = [];
+	const homeDirectory = resolve(options.homeDir ?? homedir());
+
+	if (options.projectRoot !== null) {
+		candidates.push(
+			...findProjectCandidates(options.projectRoot, options.targetFile, disabledSources, options.cache),
+		);
+	}
+
+	const pluginBundledOptions: PluginBundledFinderOptions = {
+		disabledSources,
+		...(options.cache === undefined ? {} : { cache: options.cache }),
+		...(options.pluginRoot === undefined ? {} : { pluginRoot: options.pluginRoot }),
+	};
+	candidates.push(...findPluginBundledCandidates(pluginBundledOptions));
+
+	if (!skipUserHome) {
+		candidates.push(...findUserHomeCandidates(homeDirectory, disabledSources, options.cache));
+	}
+
+	return candidates;
+}
+
+export function findPluginBundledCandidates(options: PluginBundledFinderOptions = {}): RuleCandidate[] {
+	if (options.disabledSources?.has("plugin-bundled") === true) {
+		return [];
+	}
+
+	const pluginRoot = resolvePluginRulesRoot(options.pluginRoot);
+	const ruleDirectory = join(pluginRoot, BUNDLED_RULE_SUBDIR);
+	const candidates: RuleCandidate[] = [];
+	for (const scannedFile of scanRuleFilesCached(ruleDirectory, options.cache)) {
+		candidates.push({
+			path: scannedFile.path,
+			realPath: scannedFile.realPath,
+			source: "plugin-bundled",
+			distance: GLOBAL_DISTANCE,
+			isGlobal: true,
+			isSingleFile: false,
+			relativePath: toRelativePath(pluginRoot, scannedFile.path),
+		});
+	}
+	return candidates;
+}
+
+function findProjectCandidates(
+	projectRoot: string,
+	targetFile: string | null,
+	disabledSources: ReadonlySet<string>,
+	cache: RuleDiscoveryCache | undefined,
+): RuleCandidate[] {
+	const rootDirectory = resolve(projectRoot);
+	const walkDirectories = getWalkDirectories(rootDirectory, targetFile);
+	const candidates: RuleCandidate[] = [];
+
+	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: string,
+	disabledSources: ReadonlySet<string>,
+	cache: RuleDiscoveryCache | undefined,
+): RuleCandidate[] {
+	const candidates: RuleCandidate[] = [];
+
+	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/src/rules/formatter.ts

@@ -0,0 +1,123 @@
+import { truncateBudget, truncateRule } from "./truncator.js";
+import type { LoadedRule } from "./types.js";
+
+export interface FormatOptions {
+	maxRuleChars: number;
+	maxResultChars: number;
+}
+
+type TruncatedRule = {
+	path: string;
+	relativePath: string;
+	body: string;
+};
+
+type NormalizedRule = TruncatedRule & {
+	source: LoadedRule["source"];
+};
+
+function formatRule(rule: TruncatedRule): string {
+	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: ReadonlyArray<LoadedRule>, options: FormatOptions): TruncatedRule[] {
+	const perRuleNormalized: NormalizedRule[] = 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:
+			rule.source === "plugin-bundled"
+				? truncateRule(rule.body, { maxChars: perRuleResultChars, relativePath: rule.relativePath }).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: TruncatedRule[] = [];
+
+	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: ReadonlyArray<LoadedRule>, options: FormatOptions): string {
+	if (rules.length === 0) {
+		return "";
+	}
+
+	return [
+		"## Project Instructions",
+		"",
+		truncateRules(uniqueRulesByBody(rules), options).map(formatRule).join("\n\n"),
+	].join("\n");
+}
+
+function uniqueRulesByBody(rules: ReadonlyArray<LoadedRule>): LoadedRule[] {
+	const uniqueRules: LoadedRule[] = [];
+	const seenBodies = new Set<string>();
+	const userDescriptions = new Set<string>();
+	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: ReadonlyArray<LoadedRule>,
+	targetRelativePath: string,
+	options: FormatOptions,
+): string {
+	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: string): string {
+	return body.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}

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

@@ -0,0 +1,142 @@
+import { createHash } from "node:crypto";
+import picomatch from "picomatch";
+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;
+}
+
+interface CompiledPattern {
+	pattern: string;
+	isMatch: (path: string) => boolean;
+}
+
+interface CompiledPatternSet {
+	positivePatterns: CompiledPattern[];
+	negativeMatchers: Array<(path: string) => boolean>;
+}
+
+const compiledPatternSets = new Map<string, CompiledPatternSet>();
+
+export function matchRule(input: MatcherInput): MatchResult {
+	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: RuleFrontmatter): string[] {
+	const patterns = [
+		...normalizePatternList(frontmatter.globs),
+		...normalizePatternList(frontmatter.paths),
+		...normalizePatternList(frontmatter.applyTo),
+	];
+
+	return [...new Set(patterns.map(normalizePath))];
+}
+
+export function hashContent(body: string): string {
+	return createHash("sha256").update(body).digest("hex");
+}
+
+function normalizePatternList(patterns: string | string[] | undefined): string[] {
+	if (patterns === undefined) {
+		return [];
+	}
+
+	return Array.isArray(patterns) ? patterns : [patterns];
+}
+
+function normalizePath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+function normalizedPathBases(pathBases: MatcherInput["pathBases"]): string[] {
+	const normalizedBases = [normalizePath(pathBases.projectRelative)];
+	if (pathBases.scopeRelative !== undefined) {
+		normalizedBases.push(normalizePath(pathBases.scopeRelative));
+	}
+	normalizedBases.push(normalizePath(pathBases.basename));
+	return normalizedBases;
+}
+
+function compiledPatternSetFor(patterns: ReadonlyArray<string>): CompiledPatternSet {
+	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: ReadonlyArray<string>): CompiledPatternSet {
+	const positivePatterns: CompiledPattern[] = [];
+	const negativeMatchers: Array<(path: string) => boolean> = [];
+
+	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: string): (path: string) => boolean {
+	return picomatch(normalizePath(pattern), { bash: true, dot: true });
+}
+
+function isExcluded(pathBase: string, negativeMatchers: ReadonlyArray<(path: string) => boolean>): boolean {
+	for (const isMatch of negativeMatchers) {
+		if (isMatch(pathBase)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function noMatch(): MatchResult {
+	return { matched: false, reason: { kind: "no-match" } };
+}

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

@@ -0,0 +1,33 @@
+import { SOURCE_PRIORITY } from "./constants.js";
+import type { RuleCandidate } from "./types.js";
+
+export function sortCandidates<T extends RuleCandidate>(candidates: ReadonlyArray<T>): T[] {
+	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: RuleCandidate, b: RuleCandidate): number {
+	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: boolean, b: boolean): number {
+	return Number(a) - Number(b);
+}
+
+function compareNumber(a: number, b: number): number {
+	return a - b;
+}
+
+function compareString(a: string, b: string): number {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}