oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/components/rules/dist/codex-hook.js

@@ -1,127 +0,0 @@
-import { configFromEnvironment } from "./config.js";
-import { hasContextPressureMarker, transcriptHasContextPressureMarker } from "./context-pressure.js";
-import { createHookDebugTimer } from "./debug-log.js";
-import { fingerprintDynamicTargets } from "./dynamic-target-fingerprints.js";
-import { withDynamicBudget } from "./event-budget.js";
-import { formatAdditionalContextOutput } from "./hook-output.js";
-import { displayPath, uniqueStrings } from "./path-utils.js";
-import { claimPostCompactPending, clearSessionState, hasPostCompactPending, hydrateEngineState, isPostCompactRecoveryInProgress, markSessionCompacted, persistEngineState, sessionCachePath, } from "./persistent-cache.js";
-import { withPostCompactBudget } from "./post-compact-budget.js";
-import { claimedPostCompactKind, shouldSkipPostCompactClaim } from "./post-compact-claim.js";
-import { createRulesEngine } from "./rules-engine-factory.js";
-import { runStaticInjection } from "./static-injection.js";
-import { extractCodexToolPaths } from "./tool-paths.js";
-import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
-export async function runSessionStartHook(input, options = {}) {
-    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
-    if (input.source === "clear") {
-        clearSessionState(cachePath);
-    }
-    else if (input.source !== "resume" && input.source !== "compact" && !hasPostCompactPending(cachePath)) {
-        clearSessionState(cachePath);
-    }
-    const postCompactClaim = input.source === "clear" ? "not-pending" : claimPostCompactPending(cachePath, "static");
-    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "static") ??
-        (input.source === "compact" && postCompactClaim === "not-pending" ? "static" : undefined);
-    if (shouldSkipPostCompactClaim(postCompactClaim, input.source === "compact" && isPostCompactRecoveryInProgress(cachePath, "static"))) {
-        return "";
-    }
-    const transcriptPath = input.source === "clear" ? null : input.transcript_path;
-    return runStaticInjection(input.cwd, transcriptPath, "SessionStart", cachePath, options, completedPostCompactKind, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined }, input.model);
-}
-export async function runPostCompactHook(input, options = {}) {
-    markSessionCompacted(sessionCachePath(input.session_id, options.pluginDataRoot));
-    return "";
-}
-export async function runUserPromptSubmitHook(input, options = {}) {
-    if (hasContextPressureMarker(input.prompt)) {
-        return "";
-    }
-    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
-    const postCompactClaim = claimPostCompactPending(cachePath, "static");
-    if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
-        return "";
-    }
-    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "static");
-    if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "static"))) {
-        return "";
-    }
-    return runStaticInjection(input.cwd, input.transcript_path, "UserPromptSubmit", cachePath, options, completedPostCompactKind, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined }, input.model);
-}
-export async function runPostToolUseHook(input, options = {}) {
-    const debugTimer = createHookDebugTimer("PostToolUse");
-    const config = configFromEnvironment(options.env);
-    debugTimer.lap("config", { disabled: config.disabled, mode: config.mode });
-    if (config.disabled || config.mode === "off" || config.mode === "static") {
-        debugTimer.done({ outputBytes: 0, reason: "disabled" });
-        return "";
-    }
-    const targetPaths = extractCodexToolPaths(input, input.cwd);
-    debugTimer.lap("extract", {
-        targets: targetPaths.length,
-        uniqueTargets: uniqueStrings(targetPaths).length,
-        tool: input.tool_name,
-    });
-    const firstTargetPath = targetPaths[0];
-    if (firstTargetPath === undefined) {
-        debugTimer.done({ outputBytes: 0, reason: "no-target" });
-        return "";
-    }
-    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
-    const postCompactClaim = claimPostCompactPending(cachePath, "dynamic");
-    if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
-        debugTimer.done({ outputBytes: 0, reason: "context-pressure-transcript" });
-        return "";
-    }
-    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "dynamic");
-    if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "dynamic"))) {
-        debugTimer.done({ outputBytes: 0, reason: "post-compact-recovery-in-progress" });
-        return "";
-    }
-    const dynamicConfig = withDynamicBudget(config);
-    const engine = createRulesEngine(options, completedPostCompactKind !== undefined
-        ? withPostCompactBudget(dynamicConfig, { model: input.model, transcriptPath: input.transcript_path })
-        : dynamicConfig);
-    hydrateEngineState(engine, cachePath);
-    debugTimer.lap("hydrate", {
-        dynamicDedupScopes: engine.state.dynamicDedup.size,
-        dynamicTargetFingerprints: engine.state.dynamicTargetFingerprints.size,
-        staticDedup: engine.state.staticDedup.size,
-    });
-    const dynamicTargetFingerprints = fingerprintDynamicTargets(input.cwd, targetPaths, config);
-    debugTimer.lap("fingerprint", { fingerprints: dynamicTargetFingerprints.length });
-    const pendingTargetFingerprints = dynamicTargetFingerprints.filter((target) => engine.state.dynamicTargetFingerprints.get(target.cacheKey) !== target.fingerprint);
-    debugTimer.lap("pending", { pending: pendingTargetFingerprints.length });
-    if (pendingTargetFingerprints.length === 0) {
-        persistEngineState(engine, cachePath, completedPostCompactKind);
-        debugTimer.lap("persist", { reason: "no-pending" });
-        debugTimer.done({ outputBytes: 0, reason: "no-pending" });
-        return "";
-    }
-    const loaded = engine.loadDynamicRules(input.cwd, pendingTargetFingerprints.map((target) => target.targetPath));
-    debugTimer.lap("load", { diagnostics: loaded.diagnostics.length, loadedRules: loaded.rules.length });
-    const rules = filterRulesAlreadyInTranscript(loaded.rules.filter((rule) => !engine.isStaticInjected(rule) && !engine.isDynamicInjected(rule)), input.transcript_path, (rule) => {
-        engine.markDynamicInjected(rule);
-    }, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined });
-    debugTimer.lap("filter", { rules: rules.length });
-    for (const target of pendingTargetFingerprints) {
-        engine.state.dynamicTargetFingerprints.set(target.cacheKey, target.fingerprint);
-    }
-    if (rules.length === 0) {
-        persistEngineState(engine, cachePath, completedPostCompactKind);
-        debugTimer.lap("persist", { reason: "no-rules" });
-        debugTimer.done({ outputBytes: 0, reason: "no-rules" });
-        return "";
-    }
-    const firstPendingTargetPath = pendingTargetFingerprints[0]?.targetPath ?? firstTargetPath;
-    const block = engine.formatDynamic(rules, displayPath(input.cwd, firstPendingTargetPath));
-    debugTimer.lap("format", { blockChars: block.length, rules: rules.length });
-    for (const rule of rules) {
-        engine.markDynamicInjected(rule);
-    }
-    persistEngineState(engine, cachePath, completedPostCompactKind);
-    debugTimer.lap("persist", { reason: "emit" });
-    const output = formatAdditionalContextOutput("PostToolUse", block);
-    debugTimer.done({ outputBytes: Buffer.byteLength(output), reason: "emit" });
-    return output;
-}

package/packages/omo-codex/plugin/components/rules/dist/config.d.ts

@@ -1,2 +0,0 @@
-import type { PiRulesConfig } from "./rules/types.js";
-export declare function configFromEnvironment(env?: NodeJS.ProcessEnv): PiRulesConfig;

package/packages/omo-codex/plugin/components/rules/dist/config.js

@@ -1,100 +0,0 @@
-import { SOURCE_PRIORITY } from "./rules/constants.js";
-import { defaultConfig } from "./rules/engine.js";
-export function configFromEnvironment(env = process.env) {
-    const config = defaultConfig();
-    const disableBundledRules = isTruthy(firstEnv(env, "CODEX_RULES_DISABLE_BUNDLED", "PI_RULES_DISABLE_BUNDLED"));
-    config.disabled = isTruthy(firstEnv(env, "CODEX_RULES_DISABLED", "PI_RULES_DISABLED"));
-    config.mode = parseMode(firstEnv(env, "CODEX_RULES_MODE", "PI_RULES_MODE")) ?? config.mode;
-    config.maxRuleChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RULE_CHARS", "PI_RULES_MAX_RULE_CHARS")) ??
-            config.maxRuleChars;
-    config.maxResultChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RESULT_CHARS", "PI_RULES_MAX_RESULT_CHARS")) ??
-            config.maxResultChars;
-    config.postCompactMaxRuleChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RULE_CHARS", "PI_RULES_POST_COMPACT_MAX_RULE_CHARS")) ?? config.postCompactMaxRuleChars;
-    config.postCompactMaxResultChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RESULT_CHARS", "PI_RULES_POST_COMPACT_MAX_RESULT_CHARS")) ?? config.postCompactMaxResultChars;
-    config.dynamicMaxRuleChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RULE_CHARS", "PI_RULES_DYNAMIC_MAX_RULE_CHARS")) ??
-            config.dynamicMaxRuleChars;
-    config.dynamicMaxResultChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RESULT_CHARS", "PI_RULES_DYNAMIC_MAX_RESULT_CHARS")) ?? config.dynamicMaxResultChars;
-    config.promptMaxRuleChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RULE_CHARS", "PI_RULES_PROMPT_MAX_RULE_CHARS")) ??
-            config.promptMaxRuleChars;
-    config.promptMaxResultChars =
-        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RESULT_CHARS", "PI_RULES_PROMPT_MAX_RESULT_CHARS")) ??
-            config.promptMaxResultChars;
-    config.enabledSources = parseEnabledSources(firstEnv(env, "CODEX_RULES_ENABLED_SOURCES", "PI_RULES_ENABLED_SOURCES"), disableBundledRules);
-    return config;
-}
-function firstEnv(env, ...names) {
-    for (const name of names) {
-        const value = env[name];
-        if (typeof value === "string" && value.trim().length > 0) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function isTruthy(value) {
-    if (value === undefined)
-        return false;
-    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-function parseMode(value) {
-    if (value === undefined)
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    switch (normalized) {
-        case "static":
-        case "dynamic":
-        case "both":
-        case "off":
-            return normalized;
-        default:
-            return undefined;
-    }
-}
-function parsePositiveInteger(value) {
-    if (value === undefined)
-        return undefined;
-    const parsed = Number.parseInt(value.trim(), 10);
-    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
-function parseEnabledSources(value, disableBundledRules) {
-    if (value === undefined || value.trim().toLowerCase() === "auto") {
-        return disableBundledRules ? sourcesWithoutBundledRules() : "auto";
-    }
-    const sources = [];
-    for (const rawSource of value.split(",")) {
-        const source = toRuleSource(rawSource.trim());
-        if (source === null) {
-            continue;
-        }
-        sources.push(source);
-    }
-    const enabledSources = disableBundledRules ? sources.filter((source) => source !== "plugin-bundled") : sources;
-    return enabledSources;
-}
-function sourcesWithoutBundledRules() {
-    return [...SOURCE_PRIORITY.keys()].filter((source) => source !== "plugin-bundled");
-}
-function toRuleSource(value) {
-    switch (value) {
-        case ".omo/rules":
-        case ".claude/rules":
-        case ".cursor/rules":
-        case ".github/instructions":
-        case ".github/copilot-instructions.md":
-        case "CONTEXT.md":
-        case "plugin-bundled":
-        case "~/.omo/rules":
-        case "~/.opencode/rules":
-        case "~/.claude/rules":
-            return value;
-        default:
-            return null;
-    }
-}

package/packages/omo-codex/plugin/components/rules/dist/context-pressure.d.ts

@@ -1,2 +0,0 @@
-export declare function hasContextPressureMarker(text: string): boolean;
-export declare function transcriptHasContextPressureMarker(transcriptPath: string | null | undefined): boolean;

package/packages/omo-codex/plugin/components/rules/dist/context-pressure.js

@@ -1,26 +0,0 @@
-import { readFileSync } from "node:fs";
-const CONTEXT_PRESSURE_MARKERS = [
-    "context compacted",
-    "context_length_exceeded",
-    "skill descriptions were shortened",
-    "context_too_large",
-    "codex ran out of room in the model's context window",
-    "your input exceeds the context window",
-    "long threads and multiple compactions",
-];
-export function hasContextPressureMarker(text) {
-    const normalizedText = text.toLowerCase();
-    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
-}
-export function transcriptHasContextPressureMarker(transcriptPath) {
-    if (transcriptPath === undefined || transcriptPath === null)
-        return false;
-    try {
-        return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
-    }
-    catch (error) {
-        if (error instanceof Error)
-            return false;
-        throw error;
-    }
-}

package/packages/omo-codex/plugin/components/rules/dist/debug-log.d.ts

@@ -1,8 +0,0 @@
-type DebugFieldValue = boolean | number | string | null;
-type DebugFields = Record<string, DebugFieldValue>;
-export interface HookDebugTimer {
-    lap(phase: string, fields?: DebugFields): void;
-    done(fields?: DebugFields): void;
-}
-export declare function createHookDebugTimer(hookName: string): HookDebugTimer;
-export {};

package/packages/omo-codex/plugin/components/rules/dist/debug-log.js

@@ -1,36 +0,0 @@
-import { performance } from "node:perf_hooks";
-import { debuglog } from "node:util";
-const debug = debuglog("codex-rules");
-const noopTimer = {
-    lap: () => { },
-    done: () => { },
-};
-export function createHookDebugTimer(hookName) {
-    if (!debug.enabled) {
-        return noopTimer;
-    }
-    const startMs = performance.now();
-    let lastMs = startMs;
-    return {
-        lap: (phase, fields = {}) => {
-            const nowMs = performance.now();
-            writeDebugLine(hookName, phase, nowMs - lastMs, nowMs - startMs, fields);
-            lastMs = nowMs;
-        },
-        done: (fields = {}) => {
-            const nowMs = performance.now();
-            writeDebugLine(hookName, "done", nowMs - lastMs, nowMs - startMs, fields);
-            lastMs = nowMs;
-        },
-    };
-}
-function writeDebugLine(hookName, phase, durationMs, totalMs, fields) {
-    debug("%s phase=%s ms=%s total_ms=%s%s", hookName, phase, durationMs.toFixed(3), totalMs.toFixed(3), formatFields(fields));
-}
-function formatFields(fields) {
-    const entries = Object.entries(fields);
-    if (entries.length === 0) {
-        return "";
-    }
-    return ` ${entries.map(([key, value]) => `${key}=${String(value)}`).join(" ")}`;
-}

package/packages/omo-codex/plugin/components/rules/dist/dynamic-target-fingerprints.d.ts

@@ -1,7 +0,0 @@
-import type { PiRulesConfig } from "./rules/types.js";
-export interface DynamicTargetFingerprint {
-    targetPath: string;
-    cacheKey: string;
-    fingerprint: string;
-}
-export declare function fingerprintDynamicTargets(cwd: string, targetPaths: ReadonlyArray<string>, config: PiRulesConfig): DynamicTargetFingerprint[];

package/packages/omo-codex/plugin/components/rules/dist/dynamic-target-fingerprints.js

@@ -1,65 +0,0 @@
-import { statSync } from "node:fs";
-import { resolve } from "node:path";
-import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
-import { createRuleDiscoveryCache, findRuleCandidates } from "./rules/finder.js";
-import { hashContent } from "./rules/matcher.js";
-import { sortCandidates } from "./rules/ordering.js";
-import { findProjectRoot } from "./rules/project-root.js";
-import { disabledSourcesFromConfig } from "./rules/sources.js";
-export function fingerprintDynamicTargets(cwd, targetPaths, config) {
-    const disabledSources = disabledSourcesFromConfig(config);
-    const discoveryCache = createRuleDiscoveryCache();
-    const cwdProjectRoot = findProjectRoot(cwd);
-    const fingerprints = [];
-    for (const targetPath of uniqueStrings(targetPaths)) {
-        const projectRoot = cwdProjectRoot !== null && isSameOrChildPath(targetPath, cwdProjectRoot)
-            ? cwdProjectRoot
-            : findProjectRoot(targetPath);
-        const findOptions = {
-            projectRoot,
-            targetFile: targetPath,
-            cache: discoveryCache,
-        };
-        if (disabledSources !== undefined) {
-            findOptions.disabledSources = disabledSources;
-        }
-        const candidates = findRuleCandidates(findOptions);
-        const candidateFingerprint = sortCandidates(candidates).map(fingerprintCandidate).join("\u0001");
-        const cacheKey = dynamicTargetCacheKey(targetPath);
-        fingerprints.push({
-            targetPath,
-            cacheKey,
-            fingerprint: hashContent([
-                "v1",
-                config.enabledSources === "auto" ? "auto" : config.enabledSources.join(","),
-                projectRoot ?? "",
-                cacheKey,
-                candidateFingerprint,
-            ].join("\u0000")),
-        });
-    }
-    return fingerprints;
-}
-function fingerprintCandidate(candidate) {
-    return [
-        candidate.realPath,
-        candidate.relativePath,
-        candidate.source,
-        candidate.isGlobal ? "global" : "project",
-        candidate.isSingleFile ? "single" : "multi",
-        String(candidate.distance),
-        fileFingerprint(candidate.path),
-    ].join("\u0000");
-}
-function fileFingerprint(filePath) {
-    try {
-        const stats = statSync(filePath, { bigint: true });
-        return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}`;
-    }
-    catch {
-        return "missing";
-    }
-}
-function dynamicTargetCacheKey(targetPath) {
-    return toPosixPath(resolve(targetPath));
-}

package/packages/omo-codex/plugin/components/rules/dist/event-budget.d.ts

@@ -1,3 +0,0 @@
-import type { PiRulesConfig } from "./rules/types.js";
-export declare function withDynamicBudget(config: PiRulesConfig): PiRulesConfig;
-export declare function withPromptBudget(config: PiRulesConfig): PiRulesConfig;

package/packages/omo-codex/plugin/components/rules/dist/event-budget.js

@@ -1,14 +0,0 @@
-export function withDynamicBudget(config) {
-    return {
-        ...config,
-        maxRuleChars: Math.min(config.maxRuleChars, config.dynamicMaxRuleChars),
-        maxResultChars: Math.min(config.maxResultChars, config.dynamicMaxResultChars),
-    };
-}
-export function withPromptBudget(config) {
-    return {
-        ...config,
-        maxRuleChars: Math.min(config.maxRuleChars, config.promptMaxRuleChars),
-        maxResultChars: Math.min(config.maxResultChars, config.promptMaxResultChars),
-    };
-}

package/packages/omo-codex/plugin/components/rules/dist/hook-output.d.ts

@@ -1,2 +0,0 @@
-export type ContextInjectionHookEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse";
-export declare function formatAdditionalContextOutput(eventName: ContextInjectionHookEventName, additionalContext: string): string;

package/packages/omo-codex/plugin/components/rules/dist/hook-output.js

@@ -1,24 +0,0 @@
-const MAX_ADDITIONAL_CONTEXT_CHARS = 32_000;
-export function formatAdditionalContextOutput(eventName, additionalContext) {
-    const normalizedContext = limitAdditionalContext(normalizeAdditionalContext(additionalContext));
-    if (normalizedContext.length === 0)
-        return "";
-    return `${JSON.stringify({
-        hookSpecificOutput: {
-            hookEventName: eventName,
-            additionalContext: normalizedContext,
-        },
-    })}\n`;
-}
-function normalizeAdditionalContext(additionalContext) {
-    return additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-}
-function limitAdditionalContext(additionalContext) {
-    if (additionalContext.length <= MAX_ADDITIONAL_CONTEXT_CHARS)
-        return additionalContext;
-    const marker = `\n\n[Truncated hook additional context to ${MAX_ADDITIONAL_CONTEXT_CHARS} chars to avoid Codex context overflow.]`;
-    if (marker.length >= MAX_ADDITIONAL_CONTEXT_CHARS)
-        return marker.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS);
-    const head = additionalContext.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS - marker.length).replace(/[ \t\r\n]+$/, "");
-    return `${head}${marker}`;
-}

package/packages/omo-codex/plugin/components/rules/dist/path-utils.d.ts

@@ -1,4 +0,0 @@
-export declare function displayPath(cwd: string, filePath: string): string;
-export declare function isSameOrChildPath(childPath: string, parentPath: string): boolean;
-export declare function toPosixPath(path: string): string;
-export declare function uniqueStrings(values: ReadonlyArray<string>): string[];

package/packages/omo-codex/plugin/components/rules/dist/path-utils.js

@@ -1,24 +0,0 @@
-import { isAbsolute, relative, resolve } from "node:path";
-export function displayPath(cwd, filePath) {
-    const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
-    return toPosixPath(rel);
-}
-export function isSameOrChildPath(childPath, parentPath) {
-    const childRelativePath = relative(parentPath, resolve(childPath));
-    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
-}
-export function toPosixPath(path) {
-    return path.replaceAll("\\", "/");
-}
-export function uniqueStrings(values) {
-    const uniqueValues = [];
-    const seenValues = new Set();
-    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/dist/persistent-cache.d.ts

@@ -1,13 +0,0 @@
-import { type PostCompactPendingKind } from "./post-compact-state.js";
-import type { Engine } from "./rules/engine.js";
-export type PostCompactClaimResult = "claimed" | "not-pending" | "contended";
-export declare function hydrateEngineState(engine: Engine, cachePath: string): void;
-export declare function persistEngineState(engine: Engine, cachePath: string, completedPostCompactKind?: PostCompactPendingKind): void;
-export declare function clearSessionState(cachePath: string): void;
-export declare function markSessionCompacted(cachePath: string): void;
-export declare function hasPostCompactPending(cachePath: string): boolean;
-export declare function isPostCompactPending(cachePath: string, kind: PostCompactPendingKind): boolean;
-export declare function claimPostCompactPending(cachePath: string, kind: PostCompactPendingKind): PostCompactClaimResult;
-export declare function isPostCompactRecoveryInProgress(cachePath: string, kind: PostCompactPendingKind): boolean;
-export declare function completePostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void;
-export declare function sessionCachePath(sessionId: string, pluginDataRoot: string | undefined): string;

package/packages/omo-codex/plugin/components/rules/dist/persistent-cache.js

@@ -1,172 +0,0 @@
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { postCompactKindState, postCompactPendingKinds, postCompactRecoveringKinds, } from "./post-compact-state.js";
-import { SESSION_STATE_LOCK_CONTENDED, withSessionStateLock } from "./session-state-lock.js";
-export function hydrateEngineState(engine, cachePath) {
-    const state = readSessionState(cachePath);
-    engine.state.staticDedup.clear();
-    engine.state.dynamicDedup.clear();
-    engine.state.dynamicTargetFingerprints.clear();
-    for (const key of state.staticDedup) {
-        engine.state.staticDedup.add(key);
-    }
-    for (const [scope, keys] of Object.entries(state.dynamicDedup)) {
-        engine.state.dynamicDedup.set(scope, new Set(keys));
-    }
-    for (const [targetKey, fingerprint] of Object.entries(state.dynamicTargetFingerprints ?? {})) {
-        engine.state.dynamicTargetFingerprints.set(targetKey, fingerprint);
-    }
-}
-export function persistEngineState(engine, cachePath, completedPostCompactKind) {
-    const currentState = readSessionState(cachePath);
-    const dynamicDedup = {};
-    for (const [scope, keys] of engine.state.dynamicDedup.entries()) {
-        dynamicDedup[scope] = [...keys];
-    }
-    const postCompactPending = nextPostCompactPending(currentState, completedPostCompactKind);
-    const postCompactRecovering = nextPostCompactRecovering(currentState, completedPostCompactKind);
-    writeSessionState(cachePath, {
-        staticDedup: [...engine.state.staticDedup],
-        dynamicDedup,
-        dynamicTargetFingerprints: Object.fromEntries(engine.state.dynamicTargetFingerprints.entries()),
-        ...(postCompactPending === undefined ? {} : { postCompactPending }),
-        ...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
-    });
-}
-export function clearSessionState(cachePath) {
-    rmSync(cachePath, { force: true });
-}
-export function markSessionCompacted(cachePath) {
-    const state = readSessionState(cachePath);
-    // Compaction drops injected static rule bodies, so pre-compaction static
-    // dedup marks must not suppress the post-compact recovery directive.
-    // Dynamic dedup survives: those rules are recovered as read-directive paths.
-    writeSessionState(cachePath, {
-        staticDedup: [],
-        dynamicDedup: state.dynamicDedup,
-        ...(state.dynamicTargetFingerprints === undefined
-            ? {}
-            : { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
-        postCompactPending: { static: true, dynamic: true },
-    });
-}
-export function hasPostCompactPending(cachePath) {
-    const state = readSessionState(cachePath);
-    return postCompactPendingKinds(state).size > 0 || postCompactRecoveringKinds(state).size > 0;
-}
-export function isPostCompactPending(cachePath, kind) {
-    return postCompactPendingKinds(readSessionState(cachePath)).has(kind);
-}
-export function claimPostCompactPending(cachePath, kind) {
-    const result = withSessionStateLock(cachePath, () => {
-        const state = readSessionState(cachePath);
-        const pendingKinds = postCompactPendingKinds(state);
-        if (!pendingKinds.has(kind)) {
-            return "not-pending";
-        }
-        pendingKinds.delete(kind);
-        const recoveringKinds = postCompactRecoveringKinds(state);
-        recoveringKinds.add(kind);
-        writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
-        return "claimed";
-    });
-    return result === SESSION_STATE_LOCK_CONTENDED ? "contended" : result;
-}
-export function isPostCompactRecoveryInProgress(cachePath, kind) {
-    return postCompactRecoveringKinds(readSessionState(cachePath)).has(kind);
-}
-export function completePostCompactRecovery(cachePath, kind) {
-    withSessionStateLock(cachePath, () => {
-        const state = readSessionState(cachePath);
-        const pendingKinds = postCompactPendingKinds(state);
-        const recoveringKinds = postCompactRecoveringKinds(state);
-        recoveringKinds.delete(kind);
-        writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
-    });
-}
-export function sessionCachePath(sessionId, pluginDataRoot) {
-    const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "codex-rules");
-    return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
-}
-function readSessionState(cachePath) {
-    try {
-        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
-        if (!isSerializedSessionState(parsed))
-            return emptyState();
-        return parsed;
-    }
-    catch {
-        return emptyState();
-    }
-}
-function writeSessionState(cachePath, state) {
-    mkdirSync(dirname(cachePath), { recursive: true });
-    writeFileSync(cachePath, `${JSON.stringify(state)}\n`);
-}
-function emptyState() {
-    return { staticDedup: [], dynamicDedup: {}, dynamicTargetFingerprints: {} };
-}
-function nextPostCompactPending(state, completedKind) {
-    const pendingKinds = postCompactPendingKinds(state);
-    if (completedKind !== undefined) {
-        pendingKinds.delete(completedKind);
-    }
-    if (pendingKinds.size === 0) {
-        return undefined;
-    }
-    return {
-        ...(pendingKinds.has("static") ? { static: true } : {}),
-        ...(pendingKinds.has("dynamic") ? { dynamic: true } : {}),
-    };
-}
-function nextPostCompactRecovering(state, completedKind) {
-    const recoveringKinds = postCompactRecoveringKinds(state);
-    if (completedKind !== undefined) {
-        recoveringKinds.delete(completedKind);
-    }
-    return postCompactKindState(recoveringKinds);
-}
-function stateWithPostCompactKinds(state, pendingKinds, recoveringKinds) {
-    const postCompactPending = postCompactKindState(pendingKinds);
-    const postCompactRecovering = postCompactKindState(recoveringKinds);
-    return {
-        staticDedup: state.staticDedup,
-        dynamicDedup: state.dynamicDedup,
-        ...(state.dynamicTargetFingerprints === undefined
-            ? {}
-            : { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
-        ...(postCompactPending === undefined ? {} : { postCompactPending }),
-        ...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
-    };
-}
-function safePathSegment(value) {
-    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
-}
-function isSerializedSessionState(value) {
-    if (!isRecord(value) || !Array.isArray(value["staticDedup"]) || !isRecord(value["dynamicDedup"])) {
-        return false;
-    }
-    const staticDedup = value["staticDedup"];
-    const dynamicDedup = value["dynamicDedup"];
-    const dynamicTargetFingerprints = value["dynamicTargetFingerprints"];
-    const postCompactPending = value["postCompactPending"];
-    const postCompactRecovering = value["postCompactRecovering"];
-    const compacted = value["compacted"];
-    return (staticDedup.every((item) => typeof item === "string") &&
-        Object.values(dynamicDedup).every((item) => Array.isArray(item) && item.every((nestedItem) => typeof nestedItem === "string")) &&
-        (dynamicTargetFingerprints === undefined ||
-            (isRecord(dynamicTargetFingerprints) &&
-                Object.entries(dynamicTargetFingerprints).every(([targetKey, fingerprint]) => typeof targetKey === "string" && typeof fingerprint === "string"))) &&
-        (postCompactPending === undefined || isPostCompactPendingState(postCompactPending)) &&
-        (postCompactRecovering === undefined || isPostCompactPendingState(postCompactRecovering)) &&
-        (compacted === undefined || typeof compacted === "boolean"));
-}
-function isPostCompactPendingState(value) {
-    return (isRecord(value) &&
-        (value["static"] === undefined || typeof value["static"] === "boolean") &&
-        (value["dynamic"] === undefined || typeof value["dynamic"] === "boolean"));
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/packages/omo-codex/plugin/components/rules/dist/post-compact-budget.d.ts

@@ -1,6 +0,0 @@
-import type { PiRulesConfig } from "./rules/types.js";
-export interface PostCompactBudgetContext {
-    readonly model: string;
-    readonly transcriptPath: string | null;
-}
-export declare function withPostCompactBudget(config: PiRulesConfig, context?: PostCompactBudgetContext): PiRulesConfig;