oh-my-opencode 4.8.0 → 4.9.0

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

@@ -0,0 +1,126 @@
+/**
+ * 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
+     * `.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" | "CONTEXT.md" | "plugin-bundled" | "~/.omo/rules" | "~/.opencode/rules" | "~/.claude/rules";
+/**
+ * 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;
+    dynamicMaxRuleChars: number;
+    dynamicMaxResultChars: number;
+    promptMaxRuleChars: number;
+    promptMaxResultChars: 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/dist/rules/types.js

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export {};

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

@@ -0,0 +1,6 @@
+interface RulesEngineFactoryOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}
+export declare function createRulesEngine(options: RulesEngineFactoryOptions, config?: import("./rules/types.js").PiRulesConfig): import("./rules/engine-types.js").Engine;
+export {};

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

@@ -0,0 +1,20 @@
+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";
+export function createRulesEngine(options, config = configFromEnvironment(options.env)) {
+    const platform = options.platform ?? process.platform;
+    return createEngine(config, {
+        findCandidates: (finderOptions) => findRuleCandidates({ ...finderOptions, platform }),
+        findProjectRoot,
+        readFile: (path) => {
+            try {
+                return readFileSync(path, "utf8");
+            }
+            catch {
+                return null;
+            }
+        },
+    });
+}

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

@@ -0,0 +1,3 @@
+export declare const SESSION_STATE_LOCK_CONTENDED: unique symbol;
+export type SessionStateLockResult<T> = T | typeof SESSION_STATE_LOCK_CONTENDED;
+export declare function withSessionStateLock<T>(cachePath: string, callback: () => T): SessionStateLockResult<T>;

package/packages/omo-codex/plugin/components/rules/dist/session-state-lock.js

@@ -0,0 +1,41 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+export const SESSION_STATE_LOCK_CONTENDED = Symbol("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(cachePath, callback) {
+    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) {
+    if (!isRecord(error)) {
+        return undefined;
+    }
+    return Reflect.get(error, "code");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sleepSync(milliseconds) {
+    Atomics.wait(LOCK_SLEEP_VIEW, 0, 0, milliseconds);
+}

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

@@ -0,0 +1,10 @@
+type RuntimeEnv = Readonly<Record<string, string | undefined>>;
+interface OmoResolutionDeps {
+    readonly fileExists?: (path: string) => boolean;
+    readonly platform?: NodeJS.Platform;
+}
+export declare const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
+export declare function isCodexAppServerActive(env?: RuntimeEnv): boolean;
+export declare function resolveOmoInvocation(env?: RuntimeEnv, deps?: OmoResolutionDeps): string | null;
+export declare function getSparkShellRuntimeAwareness(env?: RuntimeEnv, deps?: OmoResolutionDeps): string;
+export {};

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

@@ -0,0 +1,90 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+const SPARKSHELL_AWARENESS_MARKER = "## Sparkshell Runtime";
+export const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
+export function isCodexAppServerActive(env = process.env) {
+    const originator = env["CODEX_INTERNAL_ORIGINATOR_OVERRIDE"]?.toLowerCase() ?? "";
+    const bundleIdentifier = env["__CFBundleIdentifier"]?.toLowerCase() ?? "";
+    const shellActive = isTruthy(env["CODEX_SHELL"]);
+    return (shellActive &&
+        (originator.includes("codex desktop") ||
+            originator.includes("codex app") ||
+            bundleIdentifier === "com.openai.codex"));
+}
+function isSparkShellAppServerConfigured(env = process.env) {
+    const codexSocketPath = env["CODEX_APP_SERVER_SOCKET"]?.trim() ?? "";
+    const omoSocketPath = env["OMO_SPARKSHELL_APP_SERVER_SOCKET"]?.trim() ?? "";
+    return codexSocketPath.length > 0 || omoSocketPath.length > 0;
+}
+export function resolveOmoInvocation(env = process.env, deps = {}) {
+    const fileExists = deps.fileExists ?? existsSync;
+    const platform = deps.platform ?? process.platform;
+    const binNames = platform === "win32" ? ["omo.cmd", "omo.exe", "omo"] : ["omo"];
+    const pathDelimiter = platform === "win32" ? ";" : ":";
+    const pathEntries = (env["PATH"] ?? "").split(pathDelimiter).filter((entry) => entry.trim().length > 0);
+    for (const pathEntry of pathEntries) {
+        for (const binName of binNames) {
+            if (fileExists(join(pathEntry, binName)))
+                return "omo";
+        }
+    }
+    for (const candidateDir of omoCandidateBinDirs(env)) {
+        for (const binName of binNames) {
+            const candidate = join(candidateDir, binName);
+            if (fileExists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function omoCandidateBinDirs(env) {
+    const dirs = [];
+    const localBinDir = env["CODEX_LOCAL_BIN_DIR"]?.trim() ?? "";
+    if (localBinDir.length > 0)
+        dirs.push(localBinDir);
+    const home = env["HOME"]?.trim() || env["USERPROFILE"]?.trim() || "";
+    const codexHome = env["CODEX_HOME"]?.trim() || (home.length > 0 ? join(home, ".codex") : "");
+    if (codexHome.length > 0)
+        dirs.push(join(codexHome, "bin"));
+    if (home.length > 0)
+        dirs.push(join(home, ".local", "bin"));
+    return dirs;
+}
+export function getSparkShellRuntimeAwareness(env = process.env, deps = {}) {
+    const override = env["OMO_SPARKSHELL_AWARENESS"] ?? env["LAZYCODEX_SPARKSHELL_AWARENESS"];
+    if (isFalsy(override)) {
+        return "";
+    }
+    if (!isTruthy(override) && !isCodexAppServerActive(env) && !isSparkShellAppServerConfigured(env)) {
+        return "";
+    }
+    const resolved = resolveOmoInvocation(env, deps);
+    const invocation = resolved ?? (isTruthy(override) ? "omo" : null);
+    if (invocation === null) {
+        return "";
+    }
+    const command = /\s/.test(invocation) ? `"${invocation}"` : invocation;
+    return [
+        SPARKSHELL_AWARENESS_MARKER,
+        "",
+        `- Prefer \`${command} sparkshell <command>\` for repo inspection, CLI smoke tests, git/history checks, and bounded verification before falling back to raw shell commands.`,
+        `- Use \`${command} sparkshell --shell '<command>'\` only when shell metacharacters are required.`,
+        `- Use \`${command} sparkshell --tmux-pane <pane-id> --tail-lines 400\` to inspect an existing tmux pane. Tail lines must stay between 100 and 1000.`,
+        "- When no native sidecar or appserver is available, Sparkshell silently falls back to raw command execution. `OMO_SPARKSHELL_BIN` selects a native sidecar path.",
+        "- When `CODEX_THREAD_ID` identifies a Codex session, Sparkshell appends recent session context (first/latest user request + last 5 conversation messages) after the shell result so output consumers stay aligned with the session goals. `OMO_SPARKSHELL_SESSION_CONTEXT=0` disables it.",
+        `- Route potentially huge output (full log files, big diffs, \`cat\`/\`grep\` over large artifacts) through \`${command} sparkshell\` instead of reading it raw: oversized output is condensed to a budget while preserving error signatures, repeated patterns, session-goal-relevant lines, and head/tail. Tune with \`--budget <chars>\`; disable with \`OMO_SPARKSHELL_CONDENSE=0\`.`,
+        "- Oversized output is first summarized by the spark model (`codex exec`, default `gpt-5.3-codex-spark`) fed with the session context: the summary reproduces the output as-is (no masking) and ends with a `[sparkshell caption]` line describing what ran and which lines were omitted. `OMO_SPARKSHELL_SPARK=0` skips the model and uses deterministic condensation directly.",
+    ].join("\n");
+}
+function isTruthy(value) {
+    if (value === undefined) {
+        return false;
+    }
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function isFalsy(value) {
+    if (value === undefined) {
+        return false;
+    }
+    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}

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

@@ -0,0 +1,3 @@
+import type { CodexRulesHookOptions } from "./codex-hook-options.js";
+import type { TranscriptSearchOptions } from "./transcript-search.js";
+export declare function runStaticInjection(cwd: string, transcriptPath: string | null, eventName: "SessionStart" | "UserPromptSubmit", cachePath: string, options: CodexRulesHookOptions, completedPostCompactChannel?: "static", transcriptSearchOptions?: TranscriptSearchOptions, model?: string): string;

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

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import { configFromEnvironment } from "./config.js";
+import { withPromptBudget } from "./event-budget.js";
+import { formatAdditionalContextOutput } from "./hook-output.js";
+import { completePostCompactRecovery, hydrateEngineState, persistEngineState } from "./persistent-cache.js";
+import { withPostCompactBudget } from "./post-compact-budget.js";
+import { buildPostCompactReadDirective } from "./post-compact-directive.js";
+import { isNeverTruncatedRule } from "./rules/truncator.js";
+import { createRulesEngine } from "./rules-engine-factory.js";
+import { getSparkShellRuntimeAwareness, SPARKSHELL_AWARENESS_DEDUP_KEY } from "./sparkshell-awareness.js";
+import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+export function runStaticInjection(cwd, transcriptPath, eventName, cachePath, options, completedPostCompactChannel, transcriptSearchOptions = {}, model) {
+    const config = configFromEnvironment(options.env);
+    if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
+        if (completedPostCompactChannel !== undefined) {
+            completePostCompactRecovery(cachePath, completedPostCompactChannel);
+        }
+        return "";
+    }
+    if (completedPostCompactChannel !== undefined) {
+        return runPostCompactRecovery({
+            cwd,
+            transcriptPath,
+            eventName,
+            cachePath,
+            options,
+            channel: completedPostCompactChannel,
+            model: model ?? "",
+            config,
+        });
+    }
+    const effectiveConfig = eventName === "UserPromptSubmit" ? withPromptBudget(config) : config;
+    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);
+    const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
+        ? ""
+        : getSparkShellRuntimeAwareness(options.env);
+    if (rules.length === 0 && sparkshellAwareness.length === 0) {
+        persistEngineState(engine, cachePath);
+        return "";
+    }
+    const block = engine.formatStatic(rules);
+    for (const rule of rules) {
+        engine.markStaticInjected(rule);
+    }
+    if (sparkshellAwareness.length > 0) {
+        engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
+    }
+    persistEngineState(engine, cachePath);
+    return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
+}
+function runPostCompactRecovery(input) {
+    const effectiveConfig = withPostCompactBudget(input.config, {
+        model: input.model,
+        transcriptPath: input.transcriptPath,
+    });
+    const engine = createRulesEngine(input.options, effectiveConfig);
+    hydrateEngineState(engine, input.cachePath);
+    engine.state.cwd = input.cwd;
+    const loaded = engine.loadStaticRules(input.cwd);
+    const transcriptText = readRecoveryTranscriptText(input.transcriptPath);
+    const missingRules = filterRulesNotInTranscriptText(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptText, (rule) => {
+        engine.markStaticInjected(rule);
+    });
+    const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
+    const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
+        ? ""
+        : getSparkShellRuntimeAwareness(input.options.env);
+    if (missingRules.length === 0 && dynamicRulePaths.length === 0 && sparkshellAwareness.length === 0) {
+        persistEngineState(engine, input.cachePath, input.channel);
+        return "";
+    }
+    const fullBodyRules = missingRules.filter((rule) => isNeverTruncatedRule(ruleDisplayPath(rule)));
+    const listedRules = missingRules.filter((rule) => !isNeverTruncatedRule(ruleDisplayPath(rule)));
+    const bodyBlock = fullBodyRules.length === 0 ? "" : engine.formatStatic(fullBodyRules);
+    const directive = buildPostCompactReadDirective([...listedRules.map((rule) => rule.path), ...dynamicRulePaths], effectiveConfig.maxResultChars);
+    for (const rule of missingRules) {
+        engine.markStaticInjected(rule);
+    }
+    if (sparkshellAwareness.length > 0) {
+        engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
+    }
+    persistEngineState(engine, input.cachePath, input.channel);
+    return formatAdditionalContextOutput(input.eventName, combineStaticContext(bodyBlock, directive, sparkshellAwareness));
+}
+function readRecoveryTranscriptText(transcriptPath) {
+    if (transcriptPath === null) {
+        return null;
+    }
+    return (readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+        readTranscriptSearchText(transcriptPath));
+}
+function recoverDynamicRulePaths(engine, transcriptText, staticRules) {
+    const staticRulePaths = new Set(staticRules.map((rule) => rule.realPath));
+    const recoveredPaths = new Set();
+    for (const dedupKeys of engine.state.dynamicDedup.values()) {
+        for (const dedupKey of dedupKeys) {
+            const separatorIndex = dedupKey.lastIndexOf("::");
+            if (separatorIndex <= 0) {
+                continue;
+            }
+            const rulePath = dedupKey.slice(0, separatorIndex);
+            if (staticRulePaths.has(rulePath)) {
+                continue;
+            }
+            if (transcriptText !== null && transcriptText.includes(rulePath)) {
+                continue;
+            }
+            if (!existsSync(rulePath)) {
+                continue;
+            }
+            recoveredPaths.add(rulePath);
+        }
+    }
+    return [...recoveredPaths].sort();
+}
+function ruleDisplayPath(rule) {
+    return rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+}
+function combineStaticContext(...blocks) {
+    return blocks.filter((block) => block.trim().length > 0).join("\n\n");
+}

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

@@ -0,0 +1,6 @@
+export interface CodexPostToolUseLike {
+    tool_name: string;
+    tool_input: unknown;
+    tool_response: unknown;
+}
+export declare function extractCodexToolPaths(input: CodexPostToolUseLike, cwd: string): string[];

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

@@ -0,0 +1,168 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+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, cwd) {
+    const toolName = input.tool_name.toLowerCase();
+    if (!TRACKED_TOOL_NAMES.has(toolName) || isFailedToolResponse(input.tool_response)) {
+        return [];
+    }
+    const paths = new Set();
+    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, input, cwd) {
+    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, input, cwd) {
+    for (const key of ["input", "patch", "command", "cmd"]) {
+        const value = input[key];
+        if (typeof value === "string") {
+            addPatchHeaderPaths(paths, value, cwd);
+        }
+    }
+}
+function addPatchHeaderPaths(paths, patch, cwd) {
+    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, value, cwd) {
+    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, command, cwd) {
+    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, value, cwd, mustExist) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        addPath(paths, item, cwd, mustExist);
+    }
+}
+function addPath(paths, value, cwd, mustExist) {
+    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, filePath) {
+    return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+function isExistingFile(filePath) {
+    try {
+        return existsSync(filePath) && statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikeUrl(value) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value);
+}
+function stringProperty(value, key) {
+    const property = value[key];
+    return typeof property === "string" && property.length > 0 ? property : undefined;
+}
+function tokenizeShell(command) {
+    const tokens = [];
+    let current = "";
+    let quote = 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) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFailedToolResponse(value) {
+    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/dist/transcript-rule-filter.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedRule } from "./rules/types.js";
+import type { TranscriptSearchOptions } from "./transcript-search.js";
+export declare function filterRulesAlreadyInTranscript(rules: ReadonlyArray<LoadedRule>, transcriptPath: string | null, markInjected: (rule: LoadedRule) => void, options?: TranscriptSearchOptions): LoadedRule[];
+export declare function filterRulesNotInTranscriptText(rules: ReadonlyArray<LoadedRule>, transcriptText: string | null, markInjected: (rule: LoadedRule) => void): LoadedRule[];