oh-my-opencode 4.7.4 → 4.8.0

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

@@ -1,6 +1,3 @@
-import { realpathSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-
 import {
 	clearSession,
 	createSessionState,
@@ -14,61 +11,15 @@ import {
 	DEFAULT_MAX_RULE_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
-	PROJECT_SINGLE_FILES,
 } from "./constants.js";
-import { createRuleDiscoveryCache, type RuleDiscoveryCache } from "./finder.js";
+import { loadDynamicCandidates } from "./engine-dynamic-loader.js";
+import { loadStaticCandidates } from "./engine-static-loader.js";
+import type { DynamicMatchCache, Engine, EngineDeps } from "./engine-types.js";
 import { formatDynamicBlock, formatStaticBlock } from "./formatter.js";
-import { hashContent, matchRule } from "./matcher.js";
-import { sortCandidates } from "./ordering.js";
-import { parseRule } from "./parser.js";
 import { disabledSourcesFromConfig } from "./sources.js";
-import type { LoadedRule, MatchReason, PiRulesConfig, RuleCandidate, RuleDiagnostic, SessionState } from "./types.js";
-
-interface LoadedRuleContent {
-	frontmatter: LoadedRule["frontmatter"];
-	body: string;
-	contentHash: string;
-	diagnostic?: string;
-}
-
-type CandidateProjectMembership = Map<string, boolean>;
-type CandidateDiscoveryCache = Map<string, RuleCandidate[]>;
-type DynamicMatchCache = Map<string, MatchReason | null>;
-
-const MAX_DYNAMIC_MATCH_CACHE_ENTRIES = 4096;
-
-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;
-}
+import type { LoadedRule, PiRulesConfig, RuleDiagnostic, SessionState } from "./types.js";
 
-const ROOT_SINGLE_FILE_SOURCES = new Set(PROJECT_SINGLE_FILES.filter((source) => !source.includes("/")));
+export type { Engine, EngineDeps } from "./engine-types.js";
 
 export function defaultConfig(): PiRulesConfig {
 	return {
@@ -116,70 +67,9 @@ export function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine {
 			return emptyLoadResult(state);
 		}
 
-		const rules: LoadedRule[] = [];
-		const diagnostics: RuleDiagnostic[] = [];
-		const seenRules = new Set<string>();
-		const loadedRuleContent = new Map<string, LoadedRuleContent | null>();
-		const projectMembership = new Map<string, boolean>();
-		const disabledSources = disabledSourcesFromConfig(config);
-		const discoveryCache = createRuleDiscoveryCache();
-		const candidateDiscoveryCache: CandidateDiscoveryCache = new Map();
-		const cwdProjectRoot = deps.findProjectRoot(cwd);
-
-		for (const targetFile of uniqueStrings(targetPaths)) {
-			const projectRoot =
-				cwdProjectRoot !== null && isSameOrChildPath(targetFile, cwdProjectRoot)
-					? cwdProjectRoot
-					: deps.findProjectRoot(targetFile);
-			const findOptions: Parameters<EngineDeps["findCandidates"]>[0] = {
-				projectRoot,
-				targetFile,
-				cache: discoveryCache,
-			};
-			if (disabledSources !== undefined) {
-				findOptions.disabledSources = disabledSources;
-			}
-			const candidates = findSortedCandidatesCached(candidateDiscoveryCache, deps.findCandidates, findOptions);
-
-			for (const candidate of candidates) {
-				const loadedRule = loadCandidate(
-					candidate,
-					deps,
-					diagnostics,
-					projectRoot,
-					loadedRuleContent,
-					projectMembership,
-				);
-				if (loadedRule === null) {
-					continue;
-				}
-
-				const matchReason = matchDynamicRuleCached(
-					dynamicMatchCache,
-					projectRoot,
-					targetFile,
-					candidate,
-					loadedRule,
-					deps.matchRule ?? matchRule,
-				);
-
-				if (matchReason === null) {
-					continue;
-				}
-
-				const dedupKey = ruleDedupKey(loadedRule);
-				if (seenRules.has(dedupKey)) {
-					continue;
-				}
-
-				seenRules.add(dedupKey);
-				rules.push({ ...loadedRule, matchReason });
-			}
-		}
-
-		const sortedRules = sortCandidates(rules);
-		storeLastLoad(state, sortedRules, diagnostics);
-		return { rules: sortedRules, diagnostics };
+		const result = loadDynamicCandidates(config, deps, cwd, targetPaths, dynamicMatchCache);
+		storeLastLoad(state, result.rules, result.diagnostics);
+		return result;
 	}
 
 	return {
@@ -208,293 +98,6 @@ export function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine {
 	};
 }
 
-function matchDynamicRuleCached(
-	cache: DynamicMatchCache,
-	projectRoot: string | null,
-	targetFile: string,
-	candidate: RuleCandidate,
-	loadedRule: LoadedRule,
-	matchRuleImpl: typeof matchRule,
-): MatchReason | null {
-	const cacheKey = dynamicMatchCacheKey(projectRoot, targetFile, candidate, loadedRule.contentHash);
-	if (cache.has(cacheKey)) {
-		const cachedReason = cache.get(cacheKey) ?? null;
-		cache.delete(cacheKey);
-		cache.set(cacheKey, cachedReason);
-		return cachedReason;
-	}
-
-	const matchResult = matchRuleImpl({
-		frontmatter: loadedRule.frontmatter,
-		isSingleFile: candidate.isSingleFile,
-		pathBases: pathBasesForTarget(projectRoot, targetFile, candidate),
-	});
-	const reason = matchResult.matched ? matchResult.reason : null;
-	setDynamicMatchCacheEntry(cache, cacheKey, reason);
-	return reason;
-}
-
-function setDynamicMatchCacheEntry(cache: DynamicMatchCache, cacheKey: string, reason: MatchReason | null): void {
-	if (cache.size >= MAX_DYNAMIC_MATCH_CACHE_ENTRIES) {
-		const oldestCacheKey = cache.keys().next().value;
-		if (oldestCacheKey !== undefined) {
-			cache.delete(oldestCacheKey);
-		}
-	}
-	cache.set(cacheKey, reason);
-}
-
-function dynamicMatchCacheKey(
-	projectRoot: string | null,
-	targetFile: string,
-	candidate: RuleCandidate,
-	contentHash: string,
-): string {
-	return [
-		projectRoot ?? "",
-		toPosixPath(resolve(targetFile)),
-		candidate.realPath,
-		candidate.relativePath,
-		candidate.source,
-		candidate.isGlobal ? "global" : "project",
-		candidate.isSingleFile ? "single" : "multi",
-		String(candidate.distance),
-		contentHash,
-	].join("\0");
-}
-
-function loadStaticCandidates(candidates: ReadonlyArray<RuleCandidate>, deps: EngineDeps, projectRoot: string | null) {
-	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 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);
-}
-
-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" },
-	};
-}
-
-function ruleDedupKey(rule: LoadedRule): string {
-	return `${rule.realPath}::${rule.contentHash}`;
-}
-
-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 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;
-}
-
-function realPathOrResolved(path: string): string {
-	try {
-		return realpathSync.native(path);
-	} catch {
-		return resolve(path);
-	}
-}
-
-function findSortedCandidatesCached(
-	cache: CandidateDiscoveryCache,
-	findCandidates: EngineDeps["findCandidates"],
-	options: Parameters<EngineDeps["findCandidates"]>[0],
-): RuleCandidate[] {
-	const cacheKey = candidateDiscoveryCacheKey(options);
-	const cached = cache.get(cacheKey);
-	if (cached !== undefined) {
-		return cached;
-	}
-
-	const candidates = sortCandidates(findCandidates(options));
-	cache.set(cacheKey, candidates);
-	return candidates;
-}
-
-function candidateDiscoveryCacheKey(options: Parameters<EngineDeps["findCandidates"]>[0]): string {
-	return [
-		options.projectRoot ?? "",
-		options.targetFile === null ? "" : dirname(resolve(options.targetFile)),
-		...[...(options.disabledSources ?? [])].sort(),
-	].join("\0");
-}
-
-function isSameOrChildPath(childPath: string, parentPath: string): boolean {
-	const childRelativePath = relative(parentPath, resolve(childPath));
-	return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
-}
-
-function staticMatchReason(rule: LoadedRule): MatchReason | null {
-	if (rule.frontmatter.alwaysApply === true) {
-		return "alwaysApply";
-	}
-
-	if (rule.isSingleFile) {
-		return "single-file";
-	}
-
-	return null;
-}
-
-function isDedupedRootSingleFile(candidate: RuleCandidate, rootSingleFileSelected: boolean): boolean {
-	return rootSingleFileSelected && isRootSingleFile(candidate);
-}
-
-function isRootSingleFile(candidate: RuleCandidate): boolean {
-	return candidate.distance === 0 && candidate.isSingleFile && ROOT_SINGLE_FILE_SOURCES.has(candidate.source);
-}
-
-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,
-	};
-}
-
-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);
-}
-
-function toPosixPath(path: string): string {
-	return path.replaceAll("\\", "/");
-}
-
 function storeLastLoad(
 	state: SessionState,
 	rules: ReadonlyArray<LoadedRule>,
@@ -510,17 +113,3 @@ function emptyLoadResult(state: SessionState): { rules: LoadedRule[]; diagnostic
 	storeLastLoad(state, [], []);
 	return { rules: [], diagnostics: [] };
 }
-
-function uniqueStrings(values: ReadonlyArray<string>): string[] {
-	const uniqueValues: string[] = [];
-	const seenValues = new Set<string>();
-	for (const value of values) {
-		if (seenValues.has(value)) {
-			continue;
-		}
-
-		seenValues.add(value);
-		uniqueValues.push(value);
-	}
-	return uniqueValues;
-}

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

@@ -70,12 +70,39 @@ export function formatStaticBlock(rules: ReadonlyArray<LoadedRule>, options: For
 	if (rules.length === 0) {
 		return "";
 	}
+	if (options.maxResultChars <= 0) {
+		return "";
+	}
 
-	return [
-		"## Project Instructions",
-		"",
-		truncateRules(uniqueRulesByBody(rules), options).map(formatRule).join("\n\n"),
-	].join("\n");
+	const orderedRules = orderStaticRules(uniqueRulesByBody(rules));
+
+	return ["## Project Instructions", "", truncateRules(orderedRules, options).map(formatRule).join("\n\n")].join("\n");
+}
+
+function orderStaticRules(rules: ReadonlyArray<LoadedRule>): LoadedRule[] {
+	const hephaestusRules: LoadedRule[] = [];
+	const otherRules: LoadedRule[] = [];
+	for (const rule of rules) {
+		if (isHephaestusRule(rule)) {
+			hephaestusRules.push(rule);
+			continue;
+		}
+		otherRules.push(rule);
+	}
+	return [...hephaestusRules, ...otherRules];
+}
+
+function isHephaestusRule(rule: LoadedRule): boolean {
+	return displayFilename(rule).toLowerCase() === "hephaestus.md";
+}
+
+function displayFilename(rule: LoadedRule): string {
+	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: ReadonlyArray<LoadedRule>): LoadedRule[] {

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

@@ -0,0 +1,39 @@
+const FRONTMATTER_OPENING = "---\n";
+const FRONTMATTER_OPENING_CRLF = "---\r\n";
+
+export type ClosingDelimiter = {
+	readonly start: number;
+	readonly bodyStart: number;
+};
+
+export function stripBom(content: string): string {
+	return content.startsWith("\uFEFF") ? content.slice(1) : content;
+}
+
+export function getOpeningDelimiterLength(content: string): number {
+	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: string, openingLength: number): ClosingDelimiter | null {
+	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;
+}