oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,141 @@
+/**
+ * Public types for pi-rules.
+ *
+ * These types are stable contracts between modules. The frontmatter type
+ * mirrors omo's `RuleMetadata` plus Claude (`paths`) and Copilot (`applyTo`)
+ * aliases that are normalized into `globs` internally.
+ */
+
+/**
+ * YAML frontmatter parsed from a rule markdown file.
+ * `paths` (Claude alias) and `applyTo` (Copilot alias) are normalized into
+ * `globs` by the parser before any matcher sees this struct.
+ */
+export interface RuleFrontmatter {
+	description?: string;
+	globs?: string | string[];
+	paths?: string | string[];
+	applyTo?: string | string[];
+	alwaysApply?: boolean;
+}
+
+/**
+ * Result of parsing a rule markdown file.
+ * `body` excludes the frontmatter delimiters and the YAML payload.
+ */
+export interface ParsedRule {
+	frontmatter: RuleFrontmatter;
+	body: string;
+	/**
+	 * Diagnostic message if frontmatter parsing failed but the body was salvaged.
+	 * Empty when parsing succeeded.
+	 */
+	diagnostic?: string;
+}
+
+/**
+ * A discovered rule file candidate before parsing/matching.
+ *
+ * `path` is the absolute path as discovered (possibly via symlink).
+ * `realPath` is the canonical resolved path used for dedup.
+ * `source` identifies which discovery source produced this candidate.
+ */
+export interface RuleCandidate {
+	path: string;
+	realPath: string;
+	source: RuleSource;
+	/**
+	 * Distance from the target file directory to the directory containing this rule.
+	 * 0 = same directory, 9999 = global/user-home rule.
+	 */
+	distance: number;
+	isGlobal: boolean;
+	/**
+	 * True when this candidate is a SINGLE-FILE rule like AGENTS.md or
+	 * `.github/copilot-instructions.md` (frontmatter optional, applies always).
+	 */
+	isSingleFile: boolean;
+	/**
+	 * Path relative to project root, POSIX-normalized. Used for matcher and display.
+	 * Empty string for user-home global rules.
+	 */
+	relativePath: string;
+}
+
+/**
+ * A fully-loaded rule ready for injection.
+ */
+export interface LoadedRule extends RuleCandidate {
+	frontmatter: RuleFrontmatter;
+	body: string;
+	contentHash: string;
+	matchReason: MatchReason;
+}
+
+/**
+ * Source identifier for rule files. Used for deterministic ordering and display.
+ */
+export type RuleSource =
+	| ".omo/rules"
+	| ".claude/rules"
+	| ".cursor/rules"
+	| ".github/instructions"
+	| ".github/copilot-instructions.md"
+	| "AGENTS.md"
+	| "CLAUDE.md"
+	| "CONTEXT.md"
+	| "plugin-bundled"
+	| "~/.omo/rules"
+	| "~/.opencode/rules"
+	| "~/.claude/rules"
+	| "~/.config/opencode/AGENTS.md"
+	| "~/.claude/CLAUDE.md";
+
+/**
+ * Why a candidate matched the target file. Surfaced in the injection block so
+ * the model can attribute its behavior to a specific rule.
+ */
+export type MatchReason = "alwaysApply" | "single-file" | { kind: "glob"; pattern: string } | { kind: "no-match" };
+
+/**
+ * Truncation result.
+ */
+export interface TruncationResult {
+	body: string;
+	truncated: boolean;
+	originalLength: number;
+}
+
+/**
+ * Configuration knobs resolved from env vars and package.json.
+ */
+export interface PiRulesConfig {
+	disabled: boolean;
+	mode: "static" | "dynamic" | "both" | "off";
+	maxRuleChars: number;
+	maxResultChars: number;
+	postCompactMaxRuleChars: number;
+	postCompactMaxResultChars: number;
+	enabledSources: RuleSource[] | "auto";
+}
+
+/**
+ * Per-session in-memory dedup state.
+ *
+ * `staticDedup` keys are `{cwd}::{rulePath}::{contentHash}` strings.
+ * `dynamicDedup` stores session-scoped `{rulePath}::{contentHash}` strings.
+ */
+export interface SessionState {
+	cwd: string | undefined;
+	staticDedup: Set<string>;
+	dynamicDedup: Map<string, Set<string>>;
+	dynamicTargetFingerprints: Map<string, string>;
+	loadedRules: LoadedRule[];
+	diagnostics: RuleDiagnostic[];
+}
+
+export interface RuleDiagnostic {
+	severity: "warning" | "error";
+	source: string;
+	message: string;
+}

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

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+
+import { configFromEnvironment } from "./config.js";
+import { createEngine } from "./rules/engine.js";
+import { findRuleCandidates } from "./rules/finder.js";
+import { findProjectRoot } from "./rules/project-root.js";
+
+interface RulesEngineFactoryOptions {
+	env?: NodeJS.ProcessEnv;
+}
+
+export function createRulesEngine(options: RulesEngineFactoryOptions, config = configFromEnvironment(options.env)) {
+	return createEngine(config, {
+		findCandidates: findRuleCandidates,
+		findProjectRoot,
+		readFile: (path) => {
+			try {
+				return readFileSync(path, "utf8");
+			} catch {
+				return null;
+			}
+		},
+	});
+}

package/packages/omo-codex/plugin/components/rules/src/session-state-lock.ts

@@ -0,0 +1,47 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+
+export const SESSION_STATE_LOCK_CONTENDED = Symbol("session-state-lock-contended");
+
+export type SessionStateLockResult<T> = T | typeof SESSION_STATE_LOCK_CONTENDED;
+
+const LOCK_RETRY_COUNT = 20;
+const LOCK_RETRY_DELAY_MS = 5;
+const LOCK_SLEEP_VIEW = new Int32Array(new SharedArrayBuffer(4));
+
+export function withSessionStateLock<T>(cachePath: string, callback: () => T): SessionStateLockResult<T> {
+	const lockPath = `${cachePath}.lock`;
+	mkdirSync(dirname(cachePath), { recursive: true });
+	for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt += 1) {
+		try {
+			mkdirSync(lockPath);
+			try {
+				return callback();
+			} finally {
+				rmSync(lockPath, { recursive: true, force: true });
+			}
+		} catch (error) {
+			if (errorCode(error) === "EEXIST") {
+				sleepSync(LOCK_RETRY_DELAY_MS);
+				continue;
+			}
+			throw error;
+		}
+	}
+	return SESSION_STATE_LOCK_CONTENDED;
+}
+
+function errorCode(error: unknown): unknown {
+	if (!isRecord(error)) {
+		return undefined;
+	}
+	return Reflect.get(error, "code");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function sleepSync(milliseconds: number): void {
+	Atomics.wait(LOCK_SLEEP_VIEW, 0, 0, milliseconds);
+}

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

@@ -0,0 +1,56 @@
+import type { CodexRulesHookOptions } from "./codex-hook-options.js";
+import { configFromEnvironment } from "./config.js";
+import { formatAdditionalContextOutput } from "./hook-output.js";
+import { completePostCompactRecovery, hydrateEngineState, persistEngineState } from "./persistent-cache.js";
+import { withPostCompactBudget } from "./post-compact-budget.js";
+import { createRulesEngine } from "./rules-engine-factory.js";
+import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
+import type { TranscriptSearchOptions } from "./transcript-search.js";
+
+export function runStaticInjection(
+	cwd: string,
+	transcriptPath: string | null,
+	eventName: "SessionStart" | "UserPromptSubmit",
+	cachePath: string,
+	options: CodexRulesHookOptions,
+	completedPostCompactChannel?: "static",
+	transcriptSearchOptions: TranscriptSearchOptions = {},
+	model?: string,
+): string {
+	const config = configFromEnvironment(options.env);
+	if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
+		if (completedPostCompactChannel !== undefined) {
+			completePostCompactRecovery(cachePath, completedPostCompactChannel);
+		}
+		return "";
+	}
+
+	const effectiveConfig =
+		completedPostCompactChannel === undefined
+			? config
+			: withPostCompactBudget(config, { model: model ?? "", transcriptPath });
+	const engine = createRulesEngine(options, effectiveConfig);
+	hydrateEngineState(engine, cachePath);
+	engine.state.cwd = cwd;
+
+	const loaded = engine.loadStaticRules(cwd);
+	const rules = filterRulesAlreadyInTranscript(
+		loaded.rules.filter((rule) => !engine.isStaticInjected(rule)),
+		transcriptPath,
+		(rule) => {
+			engine.markStaticInjected(rule);
+		},
+		transcriptSearchOptions,
+	);
+	if (rules.length === 0) {
+		persistEngineState(engine, cachePath, completedPostCompactChannel);
+		return "";
+	}
+
+	const block = engine.formatStatic(rules);
+	for (const rule of rules) {
+		engine.markStaticInjected(rule);
+	}
+	persistEngineState(engine, cachePath, completedPostCompactChannel);
+	return formatAdditionalContextOutput(eventName, block);
+}

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

@@ -0,0 +1,192 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+
+export interface CodexPostToolUseLike {
+	tool_name: string;
+	tool_input: unknown;
+	tool_response: unknown;
+}
+
+const COMMAND_TOOL_NAMES = new Set(["bash", "shell_command", "exec_command"]);
+const TRACKED_TOOL_NAMES = new Set([
+	"read",
+	"read_file",
+	"mcp__filesystem__read_file",
+	"mcp__filesystem__read_multiple_files",
+	"mcp__filesystem__write_file",
+	"mcp__filesystem__edit_file",
+	"write",
+	"edit",
+	"multiedit",
+	"multi_edit",
+	"apply_patch",
+	"bash",
+	"shell_command",
+	"exec_command",
+]);
+
+export function extractCodexToolPaths(input: CodexPostToolUseLike, cwd: string): string[] {
+	const toolName = input.tool_name.toLowerCase();
+	if (!TRACKED_TOOL_NAMES.has(toolName) || isFailedToolResponse(input.tool_response)) {
+		return [];
+	}
+
+	const paths = new Set<string>();
+	const toolInput = isRecord(input.tool_input) ? input.tool_input : {};
+	addCommonPathFields(paths, toolInput, cwd);
+	addPatchPayloadPaths(paths, toolInput, cwd);
+	addPatchRecordPaths(paths, toolInput["files"], cwd);
+	addPatchRecordPaths(paths, toolInput["changes"], cwd);
+
+	if (COMMAND_TOOL_NAMES.has(toolName)) {
+		const command = stringProperty(toolInput, "command") ?? stringProperty(toolInput, "cmd");
+		const workdir = stringProperty(toolInput, "workdir") ?? stringProperty(toolInput, "cwd");
+		addCommandPaths(paths, command, workdir === undefined ? cwd : resolvePath(cwd, workdir));
+	}
+
+	return [...paths];
+}
+
+function addCommonPathFields(paths: Set<string>, input: Record<string, unknown>, cwd: string): void {
+	for (const key of ["path", "filePath", "file_path", "target", "targetPath", "target_path"]) {
+		addPath(paths, input[key], cwd, false);
+	}
+	for (const key of ["paths", "filePaths", "file_paths"]) {
+		addPathArray(paths, input[key], cwd, false);
+	}
+}
+
+function addPatchPayloadPaths(paths: Set<string>, input: Record<string, unknown>, cwd: string): void {
+	for (const key of ["input", "patch", "command", "cmd"]) {
+		const value = input[key];
+		if (typeof value === "string") {
+			addPatchHeaderPaths(paths, value, cwd);
+		}
+	}
+}
+
+function addPatchHeaderPaths(paths: Set<string>, patch: string, cwd: string): void {
+	for (const line of patch.split("\n")) {
+		for (const prefix of ["*** Add File: ", "*** Update File: ", "*** Move to: "]) {
+			if (line.startsWith(prefix)) {
+				addPath(paths, line.slice(prefix.length).trim(), cwd, false);
+			}
+		}
+	}
+}
+
+function addPatchRecordPaths(paths: Set<string>, value: unknown, cwd: string): void {
+	if (!Array.isArray(value)) return;
+	for (const item of value) {
+		if (typeof item === "string") {
+			addPath(paths, item, cwd, false);
+			continue;
+		}
+		if (!isRecord(item)) continue;
+		addCommonPathFields(paths, item, cwd);
+		for (const key of ["movePath", "move_path", "to", "from"]) {
+			addPath(paths, item[key], cwd, false);
+		}
+	}
+}
+
+function addCommandPaths(paths: Set<string>, command: string | undefined, cwd: string): void {
+	if (command === undefined) return;
+	for (const token of tokenizeShell(command)) {
+		if (token.length === 0 || token.startsWith("-") || token.includes("*")) {
+			continue;
+		}
+		addPath(paths, token, cwd, true);
+	}
+}
+
+function addPathArray(paths: Set<string>, value: unknown, cwd: string, mustExist: boolean): void {
+	if (!Array.isArray(value)) return;
+	for (const item of value) {
+		addPath(paths, item, cwd, mustExist);
+	}
+}
+
+function addPath(paths: Set<string>, value: unknown, cwd: string, mustExist: boolean): void {
+	if (typeof value !== "string" || value.length === 0 || looksLikeUrl(value)) {
+		return;
+	}
+
+	const path = resolvePath(cwd, value);
+	if (mustExist && !isExistingFile(path)) {
+		return;
+	}
+	paths.add(path);
+}
+
+function resolvePath(cwd: string, filePath: string): string {
+	return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+
+function isExistingFile(filePath: string): boolean {
+	try {
+		return existsSync(filePath) && statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function looksLikeUrl(value: string): boolean {
+	return /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value);
+}
+
+function stringProperty(value: Record<string, unknown>, key: string): string | undefined {
+	const property = value[key];
+	return typeof property === "string" && property.length > 0 ? property : undefined;
+}
+
+function tokenizeShell(command: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | null = null;
+	let escaped = false;
+
+	for (const character of command) {
+		if (escaped) {
+			current += character;
+			escaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			escaped = true;
+			continue;
+		}
+		if ((character === "'" || character === '"') && quote === null) {
+			quote = character;
+			continue;
+		}
+		if (quote === character) {
+			quote = null;
+			continue;
+		}
+		if (quote === null && /\s/.test(character)) {
+			if (current.length > 0) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += character;
+	}
+
+	if (current.length > 0) {
+		tokens.push(current);
+	}
+	return tokens;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isFailedToolResponse(value: unknown): boolean {
+	if (!isRecord(value)) return false;
+	return (
+		value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error"
+	);
+}

package/packages/omo-codex/plugin/components/rules/src/transcript-rule-filter.ts

@@ -0,0 +1,44 @@
+import type { LoadedRule } from "./rules/types.js";
+import type { TranscriptSearchOptions } from "./transcript-search.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+
+export function filterRulesAlreadyInTranscript(
+	rules: ReadonlyArray<LoadedRule>,
+	transcriptPath: string | null,
+	markInjected: (rule: LoadedRule) => void,
+	options: TranscriptSearchOptions = {},
+): LoadedRule[] {
+	if (rules.length === 0 || transcriptPath === null) {
+		return [...rules];
+	}
+
+	const transcriptText = readTranscriptSearchText(transcriptPath, options);
+	if (transcriptText === null) {
+		return [...rules];
+	}
+
+	const pendingRules: LoadedRule[] = [];
+	for (const rule of rules) {
+		if (isRuleAlreadyInTranscript(rule, transcriptText)) {
+			markInjected(rule);
+			continue;
+		}
+
+		pendingRules.push(rule);
+	}
+	return pendingRules;
+}
+
+function isRuleAlreadyInTranscript(rule: LoadedRule, transcriptText: string): boolean {
+	const bodyNeedle = rule.body.trim().slice(0, 2_000);
+	if (bodyNeedle.length === 0 || !transcriptText.includes(bodyNeedle)) {
+		return false;
+	}
+
+	const markers = [
+		`Instructions from: ${rule.path}`,
+		`Instructions from: ${rule.realPath}`,
+		rule.relativePath.length === 0 ? null : rule.relativePath,
+	].filter((marker): marker is string => marker !== null);
+	return markers.some((marker) => transcriptText.includes(marker));
+}

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

@@ -0,0 +1,108 @@
+import { readFileSync } from "node:fs";
+
+export interface TranscriptSearchOptions {
+	readonly latestCompactedReplacementOnly?: boolean;
+}
+
+export function readTranscriptSearchText(transcriptPath: string, options: TranscriptSearchOptions = {}): string | null {
+	try {
+		const rawTranscript = readFileSync(transcriptPath, "utf8");
+		if (options.latestCompactedReplacementOnly === true) {
+			return latestCompactedReplacementSearchText(rawTranscript);
+		}
+		return [rawTranscript, ...collectJsonLineStrings(rawTranscript)].join("\n");
+	} catch (error) {
+		if (!(error instanceof Error)) {
+			throw error;
+		}
+		return null;
+	}
+}
+
+function latestCompactedReplacementSearchText(rawTranscript: string): string | null {
+	const lines = rawTranscript.split(/\r?\n/);
+	let latestCompactedLineIndex = -1;
+	let replacementHistory: unknown[] | null = null;
+	for (const [index, line] of lines.entries()) {
+		const parsed = parseJsonLine(line);
+		if (!isRecord(parsed) || parsed["type"] !== "compacted") {
+			continue;
+		}
+
+		const payload = parsed["payload"];
+		if (!isRecord(payload)) {
+			continue;
+		}
+
+		const candidateReplacementHistory = payload["replacement_history"];
+		if (!Array.isArray(candidateReplacementHistory)) {
+			continue;
+		}
+
+		latestCompactedLineIndex = index;
+		replacementHistory = candidateReplacementHistory;
+	}
+
+	if (replacementHistory === null) {
+		return null;
+	}
+
+	const values: string[] = [];
+	collectStrings(replacementHistory, values);
+	const laterTranscript = lines.slice(latestCompactedLineIndex + 1).join("\n");
+	values.push(laterTranscript, ...collectJsonLineStrings(laterTranscript));
+	return values.join("\n");
+}
+
+function collectJsonLineStrings(rawTranscript: string): string[] {
+	const values: string[] = [];
+	for (const line of rawTranscript.split(/\r?\n/)) {
+		const parsed = parseJsonLine(line);
+		if (parsed !== null) {
+			collectStrings(parsed, values);
+		}
+	}
+	return values;
+}
+
+function parseJsonLine(line: string): unknown | null {
+	if (line.trim().length === 0) {
+		return null;
+	}
+
+	try {
+		const parsed: unknown = JSON.parse(line);
+		return parsed;
+	} catch (error) {
+		if (!(error instanceof Error)) {
+			throw error;
+		}
+		return null;
+	}
+}
+
+function collectStrings(value: unknown, output: string[]): void {
+	if (typeof value === "string") {
+		output.push(value);
+		return;
+	}
+
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			collectStrings(item, output);
+		}
+		return;
+	}
+
+	if (!isRecord(value)) {
+		return;
+	}
+
+	for (const item of Object.values(value)) {
+		collectStrings(item, output);
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}