oh-my-opencode 4.5.1 → 4.5.12

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

@@ -0,0 +1,326 @@
+import { RuleFrontmatterParseError } from "./errors.js";
+import type { ParsedRule, RuleFrontmatter } from "./types.js";
+
+const FRONTMATTER_OPENING = "---\n";
+const FRONTMATTER_OPENING_CRLF = "---\r\n";
+
+/** Parse markdown rule content and extract the supported YAML frontmatter subset. */
+export function parseRule(content: string): ParsedRule {
+	const normalizedContent = stripBom(content);
+	const openingLength = getOpeningDelimiterLength(normalizedContent);
+	if (openingLength === 0) {
+		return { frontmatter: {}, body: normalizedContent };
+	}
+
+	const closingDelimiter = findClosingDelimiter(normalizedContent, openingLength);
+	if (closingDelimiter === null) {
+		return {
+			frontmatter: {},
+			body: normalizedContent,
+			diagnostic: "Missing closing frontmatter delimiter",
+		};
+	}
+
+	const yamlContent = normalizedContent.slice(openingLength, closingDelimiter.start);
+	const body = normalizedContent.slice(closingDelimiter.bodyStart);
+
+	try {
+		return { frontmatter: parseYamlFrontmatter(yamlContent), body };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid YAML frontmatter";
+		return {
+			frontmatter: {},
+			body: normalizedContent,
+			diagnostic: `Malformed frontmatter: ${message}`,
+		};
+	}
+}
+
+function stripBom(content: string): string {
+	return content.startsWith("\uFEFF") ? content.slice(1) : content;
+}
+
+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;
+}
+
+function findClosingDelimiter(content: string, openingLength: number): { start: number; bodyStart: number } | 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;
+}
+
+function parseYamlFrontmatter(yamlContent: string): RuleFrontmatter {
+	const lines = yamlContent.replace(/\r\n/g, "\n").split("\n");
+	const frontmatter: RuleFrontmatter = {};
+	const globValues: string[] = [];
+	let lineIndex = 0;
+
+	while (lineIndex < lines.length) {
+		const rawLine = lines[lineIndex];
+		if (rawLine === undefined) break;
+
+		const line = stripComment(rawLine).trim();
+		if (line.length === 0) {
+			lineIndex += 1;
+			continue;
+		}
+
+		const colonIndex = line.indexOf(":");
+		if (colonIndex === -1) {
+			throw new RuleFrontmatterParseError(`Expected key-value pair on line ${lineIndex + 1}`);
+		}
+
+		const key = line.slice(0, colonIndex).trim();
+		const rawValue = line.slice(colonIndex + 1).trim();
+
+		if (key === "description") {
+			frontmatter.description = parseStringValue(rawValue);
+			lineIndex += 1;
+			continue;
+		}
+
+		if (key === "alwaysApply") {
+			frontmatter.alwaysApply = parseBooleanValue(rawValue, lineIndex + 1);
+			lineIndex += 1;
+			continue;
+		}
+
+		if (key === "globs" || key === "paths" || key === "applyTo") {
+			const parsed = parseGlobValue(rawValue, lines, lineIndex);
+			for (const glob of parsed.values) {
+				if (!globValues.includes(glob)) globValues.push(glob);
+			}
+			lineIndex += parsed.consumed;
+			continue;
+		}
+
+		lineIndex += 1;
+	}
+
+	const singleGlob = globValues[0];
+	if (globValues.length === 1 && singleGlob !== undefined) {
+		frontmatter.globs = singleGlob;
+	} else if (globValues.length > 1) {
+		frontmatter.globs = globValues;
+	}
+
+	return frontmatter;
+}
+
+function parseBooleanValue(value: string, lineNumber: number): boolean {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new RuleFrontmatterParseError(`Expected boolean on line ${lineNumber}`);
+}
+
+function parseGlobValue(rawValue: string, lines: string[], lineIndex: number): { values: string[]; consumed: number } {
+	if (rawValue.startsWith("[")) {
+		return { values: parseInlineArray(rawValue), consumed: 1 };
+	}
+
+	if (rawValue.length === 0) {
+		return parseMultilineArray(lines, lineIndex);
+	}
+
+	const value = parseStringValue(rawValue);
+	if (value.includes(",")) {
+		return {
+			values: value
+				.split(",")
+				.map((item) => item.trim())
+				.filter(Boolean),
+			consumed: 1,
+		};
+	}
+
+	return { values: [value], consumed: 1 };
+}
+
+function parseMultilineArray(lines: string[], lineIndex: number): { values: string[]; consumed: number } {
+	const values: string[] = [];
+	let consumed = 1;
+
+	for (let index = lineIndex + 1; index < lines.length; index += 1) {
+		const rawLine = lines[index];
+		if (rawLine === undefined) break;
+
+		const lineWithoutComment = stripComment(rawLine);
+		if (lineWithoutComment.trim().length === 0) {
+			consumed += 1;
+			continue;
+		}
+
+		const arrayItem = lineWithoutComment.match(/^\s+-\s*(.*)$/);
+		if (arrayItem === null) break;
+
+		values.push(parseStringValue(arrayItem[1] ?? ""));
+		consumed += 1;
+	}
+
+	return { values: values.filter(Boolean), consumed };
+}
+
+function parseInlineArray(value: string): string[] {
+	const closingBracketIndex = findClosingBracket(value);
+	if (closingBracketIndex === -1) {
+		throw new RuleFrontmatterParseError("Unclosed inline array");
+	}
+
+	const trailing = value.slice(closingBracketIndex + 1).trim();
+	if (trailing.length > 0) {
+		throw new RuleFrontmatterParseError("Unexpected content after inline array");
+	}
+
+	const content = value.slice(1, closingBracketIndex).trim();
+	if (content.length === 0) return [];
+
+	return splitCommaSeparated(content).map(parseStringValue).filter(Boolean);
+}
+
+function findClosingBracket(value: string): number {
+	let quote: string | null = null;
+	let escaped = false;
+
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (character === undefined) continue;
+
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (quote !== null && character === "\\") {
+			escaped = true;
+			continue;
+		}
+
+		if (character === '"' || character === "'") {
+			if (quote === null) quote = character;
+			else if (quote === character) quote = null;
+			continue;
+		}
+
+		if (quote === null && character === "]") return index;
+	}
+
+	return -1;
+}
+
+function splitCommaSeparated(value: string): string[] {
+	const values: string[] = [];
+	let current = "";
+	let quote: string | null = null;
+	let escaped = false;
+
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (character === undefined) continue;
+
+		if (escaped) {
+			current += character;
+			escaped = false;
+			continue;
+		}
+
+		if (quote !== null && character === "\\") {
+			current += character;
+			escaped = true;
+			continue;
+		}
+
+		if (character === '"' || character === "'") {
+			if (quote === null) quote = character;
+			else if (quote === character) quote = null;
+			current += character;
+			continue;
+		}
+
+		if (quote === null && character === ",") {
+			values.push(current.trim());
+			current = "";
+			continue;
+		}
+
+		current += character;
+	}
+
+	if (quote !== null) {
+		throw new RuleFrontmatterParseError("Unclosed quoted value");
+	}
+
+	values.push(current.trim());
+	return values.filter(Boolean);
+}
+
+function parseStringValue(value: string): string {
+	if (value.length === 0) return "";
+	if (value.startsWith('"')) return parseJsonString(value);
+	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	if (value.startsWith("'")) throw new RuleFrontmatterParseError("Unclosed quoted value");
+	return value;
+}
+
+function parseJsonString(value: string): string {
+	let parsedValue: unknown;
+	try {
+		parsedValue = JSON.parse(value);
+	} catch {
+		throw new RuleFrontmatterParseError("Invalid JSON-quoted string");
+	}
+
+	if (typeof parsedValue !== "string") {
+		throw new RuleFrontmatterParseError("Expected JSON-quoted string");
+	}
+
+	return parsedValue;
+}
+
+function stripComment(line: string): string {
+	let quote: string | null = null;
+	let escaped = false;
+
+	for (let index = 0; index < line.length; index += 1) {
+		const character = line[index];
+		if (character === undefined) continue;
+
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (quote !== null && character === "\\") {
+			escaped = true;
+			continue;
+		}
+
+		if (character === '"' || character === "'") {
+			if (quote === null) quote = character;
+			else if (quote === character) quote = null;
+			continue;
+		}
+
+		if (quote === null && character === "#") return line.slice(0, index);
+	}
+
+	return line;
+}

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

@@ -0,0 +1,55 @@
+import { statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_MANIFEST_PATH = join(".codex-plugin", "plugin.json");
+
+export function resolvePluginRulesRoot(pluginRoot: string | undefined, moduleUrl = import.meta.url): string {
+	const configuredRoot = pluginRoot ?? process.env["PLUGIN_ROOT"];
+	if (configuredRoot !== undefined && configuredRoot.trim().length > 0) {
+		return resolveRulesComponentRoot(resolve(configuredRoot));
+	}
+
+	const discoveredRoot = findNearestPluginRoot(dirname(fileURLToPath(moduleUrl)));
+	if (discoveredRoot !== null) {
+		return resolveRulesComponentRoot(discoveredRoot);
+	}
+
+	return fileURLToPath(new URL("../../..", moduleUrl));
+}
+
+function findNearestPluginRoot(startDirectory: string): string | null {
+	let currentDirectory = resolve(startDirectory);
+	while (true) {
+		if (isFile(join(currentDirectory, PLUGIN_MANIFEST_PATH))) {
+			return currentDirectory;
+		}
+
+		const parentDirectory = dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+}
+
+function resolveRulesComponentRoot(pluginRoot: string): string {
+	const componentRoot = join(pluginRoot, "components", "rules");
+	return isDirectory(componentRoot) ? componentRoot : pluginRoot;
+}
+
+function isFile(path: string): boolean {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function isDirectory(path: string): boolean {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}

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

@@ -0,0 +1,30 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+import { PROJECT_MARKERS } from "./constants.js";
+
+export function findProjectRoot(startPath: string, markers: ReadonlyArray<string> = PROJECT_MARKERS): string | null {
+	const resolvedStartPath = resolve(startPath);
+
+	if (!existsSync(resolvedStartPath)) {
+		return null;
+	}
+
+	const startStats = statSync(resolvedStartPath);
+	let currentDirectory = startStats.isDirectory() ? resolvedStartPath : dirname(resolvedStartPath);
+	const filesystemRoot = resolve("/");
+
+	while (true) {
+		for (const marker of markers) {
+			if (existsSync(join(currentDirectory, marker))) {
+				return currentDirectory;
+			}
+		}
+
+		if (currentDirectory === filesystemRoot) {
+			return null;
+		}
+
+		currentDirectory = dirname(currentDirectory);
+	}
+}

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

@@ -0,0 +1,162 @@
+import { type Dirent, existsSync, lstatSync, readdirSync, realpathSync, type Stats, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+
+import { DEFAULT_MAX_SCAN_FILES, RULE_FILE_EXTENSIONS, SCANNER_EXCLUDED_DIRS } from "./constants.js";
+
+export interface ScanOptions {
+	rootDir: string;
+	excludedDirs?: ReadonlyArray<string>;
+	/** Maximum recursion depth. Default: 10 */
+	maxDepth?: number;
+	maxFiles?: number;
+}
+
+export interface ScannedFile {
+	/** Absolute path as encountered (may be a symlink). */
+	path: string;
+	/** Real (resolved) path; same as path if not a symlink. */
+	realPath: string;
+}
+
+export function scanRuleFiles(options: ScanOptions): ScannedFile[] {
+	const rootPath = toAbsolutePath(options.rootDir);
+	if (!existsSync(rootPath)) {
+		return [];
+	}
+
+	let rootStats: Stats;
+	try {
+		rootStats = statSync(rootPath);
+	} catch {
+		return [];
+	}
+
+	if (!rootStats.isDirectory()) {
+		return [];
+	}
+
+	const results: ScannedFile[] = [];
+	const visitedDirectories = new Set<string>();
+	const excludedDirs = new Set(options.excludedDirs ?? SCANNER_EXCLUDED_DIRS);
+	const maxDepth = options.maxDepth ?? 10;
+	const maxFiles = normalizeMaxFiles(options.maxFiles);
+
+	scanDirectory(rootPath, 0, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+	return results;
+}
+
+function normalizeMaxFiles(maxFiles: number | undefined): number {
+	const value = maxFiles ?? DEFAULT_MAX_SCAN_FILES;
+	if (!Number.isFinite(value) || value < 0) return DEFAULT_MAX_SCAN_FILES;
+	return Math.floor(value);
+}
+
+function toAbsolutePath(filePath: string): string {
+	return isAbsolute(filePath) ? filePath : resolve(filePath);
+}
+
+function scanDirectory(
+	directoryPath: string,
+	depth: number,
+	maxDepth: number,
+	maxFiles: number,
+	excludedDirs: ReadonlySet<string>,
+	visitedDirectories: Set<string>,
+	results: ScannedFile[],
+): void {
+	if (results.length >= maxFiles) {
+		return;
+	}
+
+	let realDirectoryPath: string;
+	try {
+		realDirectoryPath = realpathSync.native(directoryPath);
+	} catch {
+		return;
+	}
+
+	if (visitedDirectories.has(realDirectoryPath)) {
+		return;
+	}
+	visitedDirectories.add(realDirectoryPath);
+
+	let entries: Dirent[];
+	try {
+		entries = readdirSync(directoryPath, { withFileTypes: true }).sort((leftEntry, rightEntry) =>
+			leftEntry.name.localeCompare(rightEntry.name),
+		);
+	} catch {
+		return;
+	}
+
+	for (const entry of entries) {
+		if (results.length >= maxFiles) {
+			return;
+		}
+
+		const entryPath = join(directoryPath, entry.name);
+
+		if (entry.isDirectory()) {
+			if (!excludedDirs.has(entry.name) && depth < maxDepth) {
+				scanDirectory(entryPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+			}
+			continue;
+		}
+
+		if (entry.isSymbolicLink()) {
+			scanSymbolicLink(entryPath, entry.name, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+			continue;
+		}
+
+		if (entry.isFile() && isRuleFile(entry.name)) {
+			results.push({ path: entryPath, realPath: resolveRealPath(entryPath) });
+		}
+	}
+}
+
+function scanSymbolicLink(
+	linkPath: string,
+	linkName: string,
+	depth: number,
+	maxDepth: number,
+	maxFiles: number,
+	excludedDirs: ReadonlySet<string>,
+	visitedDirectories: Set<string>,
+	results: ScannedFile[],
+): void {
+	if (results.length >= maxFiles) {
+		return;
+	}
+
+	let targetStats: Stats;
+	try {
+		targetStats = statSync(linkPath);
+	} catch {
+		return;
+	}
+
+	if (targetStats.isDirectory()) {
+		if (!excludedDirs.has(linkName) && depth < maxDepth) {
+			scanDirectory(linkPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
+		}
+		return;
+	}
+
+	if (targetStats.isFile() && isRuleFile(linkName)) {
+		results.push({ path: linkPath, realPath: resolveRealPath(linkPath) });
+	}
+}
+
+function isRuleFile(fileName: string): boolean {
+	return RULE_FILE_EXTENSIONS.some((extension) => fileName.endsWith(extension));
+}
+
+function resolveRealPath(filePath: string): string {
+	try {
+		const realPath = realpathSync.native(filePath);
+		const fileStats = lstatSync(filePath);
+		return fileStats.isSymbolicLink() ? realPath : filePath;
+	} catch {
+		return filePath;
+	}
+}

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

@@ -0,0 +1,67 @@
+import { TRUNCATION_NOTICE } from "./constants.js";
+import type { TruncationResult } from "./types.js";
+
+type BudgetRule = {
+	body: string;
+	relativePath: string;
+};
+
+type BudgetResult = BudgetRule & {
+	truncated: boolean;
+};
+
+function truncationNotice(relativePath: string): string {
+	return TRUNCATION_NOTICE.replace("{path}", relativePath);
+}
+
+function safeSliceEnd(body: string, end: number): number {
+	if (end <= 0) {
+		return 0;
+	}
+
+	const lastCodeUnit = body.charCodeAt(end - 1);
+	if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) {
+		return end - 1;
+	}
+
+	return end;
+}
+
+export function truncateRule(body: string, options: { maxChars: number; relativePath: string }): TruncationResult {
+	if (body.length <= options.maxChars) {
+		return { body, truncated: false, originalLength: body.length };
+	}
+
+	const notice = truncationNotice(options.relativePath);
+	if (options.maxChars < notice.length) {
+		return { body: notice, truncated: true, originalLength: body.length };
+	}
+
+	const sliceEnd = safeSliceEnd(body, options.maxChars - notice.length);
+	return { body: `${body.slice(0, sliceEnd)}${notice}`, truncated: true, originalLength: body.length };
+}
+
+export function truncateBudget(input: { rules: ReadonlyArray<BudgetRule>; maxResultChars: number }): BudgetResult[] {
+	const results: BudgetResult[] = [];
+	let remainingBudget = input.maxResultChars;
+
+	for (const rule of input.rules) {
+		if (remainingBudget >= rule.body.length) {
+			results.push({ body: rule.body, truncated: false, relativePath: rule.relativePath });
+			remainingBudget -= rule.body.length;
+			continue;
+		}
+
+		const notice = truncationNotice(rule.relativePath);
+		if (remainingBudget <= notice.length) {
+			break;
+		}
+
+		const sliceEnd = safeSliceEnd(rule.body, remainingBudget - notice.length);
+		const body = `${rule.body.slice(0, sliceEnd)}${notice}`;
+		results.push({ body, truncated: true, relativePath: rule.relativePath });
+		remainingBudget -= body.length;
+	}
+
+	return results;
+}