oh-my-opencode 4.7.5 → 4.8.0

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

@@ -0,0 +1,84 @@
+import { isCandidateWithinProjectCached } from "./engine-paths.js";
+import type { CandidateProjectMembership, EngineDeps, LoadedRuleContent } from "./engine-types.js";
+import { hashContent } from "./matcher.js";
+import { parseRule } from "./parser.js";
+import type { LoadedRule, MatchReason, RuleCandidate, RuleDiagnostic } from "./types.js";
+
+export function loadCandidate(
+	candidate: RuleCandidate,
+	deps: EngineDeps,
+	diagnostics: RuleDiagnostic[],
+	projectRoot: string | null,
+	loadedRuleContent?: Map<string, LoadedRuleContent | null>,
+	projectMembership?: CandidateProjectMembership,
+): (LoadedRule & { matchReason: MatchReason }) | null {
+	if (!isCandidateWithinProjectCached(candidate, projectRoot, projectMembership)) {
+		diagnostics.push({
+			severity: "warning",
+			source: candidate.path,
+			message: "Rule file resolves outside project root",
+		});
+		return null;
+	}
+
+	const cachedContent = loadedRuleContent?.get(candidate.realPath);
+	if (cachedContent !== undefined) {
+		return loadedRuleFromContent(candidate, cachedContent, diagnostics);
+	}
+
+	const content = deps.readFile(candidate.path);
+	if (content === null) {
+		loadedRuleContent?.set(candidate.realPath, null);
+		diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+		return null;
+	}
+
+	const parsed = parseRule(content);
+	const loadedContent = {
+		frontmatter: parsed.frontmatter,
+		body: parsed.body,
+		contentHash: hashContent(content),
+		...(parsed.diagnostic === undefined ? {} : { diagnostic: parsed.diagnostic }),
+	} satisfies LoadedRuleContent;
+	loadedRuleContent?.set(candidate.realPath, loadedContent);
+	return loadedRuleFromContent(candidate, loadedContent, diagnostics);
+}
+
+export function ruleDedupKey(rule: LoadedRule): string {
+	return `${rule.realPath}::${rule.contentHash}`;
+}
+
+export function staticMatchReason(rule: LoadedRule): MatchReason | null {
+	if (rule.frontmatter.alwaysApply === true) {
+		return "alwaysApply";
+	}
+
+	if (rule.isSingleFile) {
+		return "single-file";
+	}
+
+	return null;
+}
+
+function loadedRuleFromContent(
+	candidate: RuleCandidate,
+	content: LoadedRuleContent | null,
+	diagnostics: RuleDiagnostic[],
+): (LoadedRule & { matchReason: MatchReason }) | null {
+	if (content === null) {
+		diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+		return null;
+	}
+
+	if (content.diagnostic !== undefined) {
+		diagnostics.push({ severity: "warning", source: candidate.path, message: content.diagnostic });
+	}
+
+	return {
+		...candidate,
+		frontmatter: content.frontmatter,
+		body: content.body,
+		contentHash: content.contentHash,
+		matchReason: { kind: "no-match" },
+	};
+}

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

@@ -0,0 +1,103 @@
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+import { PROJECT_SINGLE_FILES } from "./constants.js";
+import type { CandidateProjectMembership } from "./engine-types.js";
+import type { RuleCandidate } from "./types.js";
+
+const ROOT_SINGLE_FILE_SOURCES = new Set(PROJECT_SINGLE_FILES.filter((source) => !source.includes("/")));
+
+export function isCandidateWithinProjectCached(
+	candidate: RuleCandidate,
+	projectRoot: string | null,
+	projectMembership: CandidateProjectMembership | undefined,
+): boolean {
+	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: string, parentPath: string): boolean {
+	const childRelativePath = relative(parentPath, resolve(childPath));
+	return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+
+export function isRootSingleFile(candidate: RuleCandidate): boolean {
+	return candidate.distance === 0 && candidate.isSingleFile && ROOT_SINGLE_FILE_SOURCES.has(candidate.source);
+}
+
+export function pathBasesForTarget(
+	projectRoot: string | null,
+	targetFile: string,
+	candidate: RuleCandidate,
+): { projectRelative: string; scopeRelative?: string; basename: string } {
+	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: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+function isCandidateWithinProject(candidate: RuleCandidate, projectRoot: string | null): boolean {
+	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: string): string {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve(path);
+	}
+}
+
+function scopeDirectoryForCandidate(projectRoot: string, candidate: RuleCandidate): string | null {
+	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/src/rules/engine-static-loader.ts

@@ -0,0 +1,43 @@
+import { loadCandidate, staticMatchReason } from "./engine-loader.js";
+import { isRootSingleFile } from "./engine-paths.js";
+import type { EngineDeps } from "./engine-types.js";
+import { sortCandidates } from "./ordering.js";
+import type { LoadedRule, RuleCandidate, RuleDiagnostic } from "./types.js";
+
+export function loadStaticCandidates(
+	candidates: ReadonlyArray<RuleCandidate>,
+	deps: EngineDeps,
+	projectRoot: string | null,
+): { rules: LoadedRule[]; diagnostics: RuleDiagnostic[] } {
+	const rules: LoadedRule[] = [];
+	const diagnostics: RuleDiagnostic[] = [];
+	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: RuleCandidate, rootSingleFileSelected: boolean): boolean {
+	return rootSingleFileSelected && isRootSingleFile(candidate);
+}

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

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