@code-yeongyu/lazycodex 0.1.1

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

@@ -0,0 +1,354 @@
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { clearSession, createSessionState, isDynamicInjected as isDynamicInjectedInState, isStaticInjected as isStaticInjectedInState, markDynamicInjected as markDynamicInjectedInState, markStaticInjected as markStaticInjectedInState, } from "./cache.js";
+import { DEFAULT_MAX_RESULT_CHARS, DEFAULT_MAX_RULE_CHARS, DEFAULT_POST_COMPACT_MAX_RESULT_CHARS, DEFAULT_POST_COMPACT_MAX_RULE_CHARS, PROJECT_SINGLE_FILES, SOURCE_PRIORITY, } from "./constants.js";
+import { createRuleDiscoveryCache } from "./finder.js";
+import { formatDynamicBlock, formatStaticBlock } from "./formatter.js";
+import { hashContent, matchRule } from "./matcher.js";
+import { sortCandidates } from "./ordering.js";
+import { parseRule } from "./parser.js";
+const MAX_DYNAMIC_MATCH_CACHE_ENTRIES = 4096;
+const ROOT_SINGLE_FILE_SOURCES = new Set(PROJECT_SINGLE_FILES.filter((source) => !source.includes("/")));
+export function defaultConfig() {
+    return {
+        disabled: false,
+        mode: "both",
+        maxRuleChars: DEFAULT_MAX_RULE_CHARS,
+        maxResultChars: DEFAULT_MAX_RESULT_CHARS,
+        postCompactMaxRuleChars: DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
+        postCompactMaxResultChars: DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
+        enabledSources: "auto",
+    };
+}
+export function createEngine(config, deps) {
+    const state = createSessionState();
+    const dynamicMatchCache = new Map();
+    function loadStaticRules(cwd) {
+        state.cwd = cwd;
+        if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
+            return emptyLoadResult(state);
+        }
+        const projectRoot = deps.findProjectRoot(cwd);
+        const findOptions = {
+            projectRoot,
+            targetFile: null,
+        };
+        const disabledSources = disabledSourcesFor(config);
+        if (disabledSources !== undefined) {
+            findOptions.disabledSources = disabledSources;
+        }
+        const candidates = deps.findCandidates(findOptions);
+        const result = loadStaticCandidates(candidates, deps, projectRoot);
+        storeLastLoad(state, result.rules, result.diagnostics);
+        return result;
+    }
+    function loadDynamicRules(cwd, targetPaths) {
+        state.cwd = cwd;
+        if (config.disabled || config.mode === "off" || config.mode === "static" || targetPaths.length === 0) {
+            return emptyLoadResult(state);
+        }
+        const rules = [];
+        const diagnostics = [];
+        const seenRules = new Set();
+        const loadedRuleContent = new Map();
+        const projectMembership = new Map();
+        const disabledSources = disabledSourcesFor(config);
+        const discoveryCache = createRuleDiscoveryCache();
+        const candidateDiscoveryCache = new Map();
+        const cwdProjectRoot = deps.findProjectRoot(cwd);
+        for (const targetFile of uniqueStrings(targetPaths)) {
+            const projectRoot = cwdProjectRoot !== null && isSameOrChildPath(targetFile, cwdProjectRoot)
+                ? cwdProjectRoot
+                : deps.findProjectRoot(targetFile);
+            const findOptions = {
+                projectRoot,
+                targetFile,
+                cache: discoveryCache,
+            };
+            if (disabledSources !== undefined) {
+                findOptions.disabledSources = disabledSources;
+            }
+            const candidates = findSortedCandidatesCached(candidateDiscoveryCache, deps.findCandidates, findOptions);
+            for (const candidate of candidates) {
+                const loadedRule = loadCandidate(candidate, deps, diagnostics, projectRoot, loadedRuleContent, projectMembership);
+                if (loadedRule === null) {
+                    continue;
+                }
+                const matchReason = matchDynamicRuleCached(dynamicMatchCache, projectRoot, targetFile, candidate, loadedRule, deps.matchRule ?? matchRule);
+                if (matchReason === null) {
+                    continue;
+                }
+                const dedupKey = ruleDedupKey(loadedRule);
+                if (seenRules.has(dedupKey)) {
+                    continue;
+                }
+                seenRules.add(dedupKey);
+                rules.push({ ...loadedRule, matchReason });
+            }
+        }
+        const sortedRules = sortCandidates(rules);
+        storeLastLoad(state, sortedRules, diagnostics);
+        return { rules: sortedRules, diagnostics };
+    }
+    return {
+        state,
+        config,
+        loadStaticRules,
+        loadDynamicRules,
+        formatStatic: (rules) => formatStaticBlock(rules, { maxRuleChars: config.maxRuleChars, maxResultChars: config.maxResultChars }),
+        formatDynamic: (rules, target) => formatDynamicBlock(rules, target, {
+            maxRuleChars: config.maxRuleChars,
+            maxResultChars: config.maxResultChars,
+        }),
+        resetSession: (cwd) => {
+            clearSession(state);
+            dynamicMatchCache.clear();
+            if (cwd !== undefined) {
+                state.cwd = cwd;
+            }
+        },
+        isStaticInjected: (rule) => isStaticInjectedInState(state, rule),
+        isDynamicInjected: (rule) => isDynamicInjectedInState(state, rule),
+        markStaticInjected: (rule) => markStaticInjectedInState(state, rule),
+        markDynamicInjected: (rule) => markDynamicInjectedInState(state, rule),
+    };
+}
+function matchDynamicRuleCached(cache, projectRoot, targetFile, candidate, loadedRule, matchRuleImpl) {
+    const cacheKey = dynamicMatchCacheKey(projectRoot, targetFile, candidate, loadedRule.contentHash);
+    if (cache.has(cacheKey)) {
+        const cachedReason = cache.get(cacheKey) ?? null;
+        cache.delete(cacheKey);
+        cache.set(cacheKey, cachedReason);
+        return cachedReason;
+    }
+    const matchResult = matchRuleImpl({
+        frontmatter: loadedRule.frontmatter,
+        isSingleFile: candidate.isSingleFile,
+        pathBases: pathBasesForTarget(projectRoot, targetFile, candidate),
+    });
+    const reason = matchResult.matched ? matchResult.reason : null;
+    setDynamicMatchCacheEntry(cache, cacheKey, reason);
+    return reason;
+}
+function setDynamicMatchCacheEntry(cache, cacheKey, reason) {
+    if (cache.size >= MAX_DYNAMIC_MATCH_CACHE_ENTRIES) {
+        const oldestCacheKey = cache.keys().next().value;
+        if (oldestCacheKey !== undefined) {
+            cache.delete(oldestCacheKey);
+        }
+    }
+    cache.set(cacheKey, reason);
+}
+function dynamicMatchCacheKey(projectRoot, targetFile, candidate, contentHash) {
+    return [
+        projectRoot ?? "",
+        toPosixPath(resolve(targetFile)),
+        candidate.realPath,
+        candidate.relativePath,
+        candidate.source,
+        candidate.isGlobal ? "global" : "project",
+        candidate.isSingleFile ? "single" : "multi",
+        String(candidate.distance),
+        contentHash,
+    ].join("\0");
+}
+function loadStaticCandidates(candidates, deps, projectRoot) {
+    const rules = [];
+    const diagnostics = [];
+    let rootSingleFileSelected = false;
+    for (const candidate of sortCandidates(candidates)) {
+        if (isDedupedRootSingleFile(candidate, rootSingleFileSelected)) {
+            continue;
+        }
+        const loadedRule = loadCandidate(candidate, deps, diagnostics, projectRoot);
+        if (loadedRule === null) {
+            continue;
+        }
+        const matchReason = staticMatchReason(loadedRule);
+        if (matchReason === null) {
+            continue;
+        }
+        if (isRootSingleFile(candidate)) {
+            rootSingleFileSelected = true;
+        }
+        rules.push({ ...loadedRule, matchReason });
+    }
+    return { rules: sortCandidates(rules), diagnostics };
+}
+function loadCandidate(candidate, deps, diagnostics, projectRoot, loadedRuleContent, projectMembership) {
+    if (!isCandidateWithinProjectCached(candidate, projectRoot, projectMembership)) {
+        diagnostics.push({
+            severity: "warning",
+            source: candidate.path,
+            message: "Rule file resolves outside project root",
+        });
+        return null;
+    }
+    const cachedContent = loadedRuleContent?.get(candidate.realPath);
+    if (cachedContent !== undefined) {
+        return loadedRuleFromContent(candidate, cachedContent, diagnostics);
+    }
+    const content = deps.readFile(candidate.path);
+    if (content === null) {
+        loadedRuleContent?.set(candidate.realPath, null);
+        diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+        return null;
+    }
+    const parsed = parseRule(content);
+    const loadedContent = {
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        contentHash: hashContent(content),
+        ...(parsed.diagnostic === undefined ? {} : { diagnostic: parsed.diagnostic }),
+    };
+    loadedRuleContent?.set(candidate.realPath, loadedContent);
+    return loadedRuleFromContent(candidate, loadedContent, diagnostics);
+}
+function loadedRuleFromContent(candidate, content, diagnostics) {
+    if (content === null) {
+        diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+        return null;
+    }
+    if (content.diagnostic !== undefined) {
+        diagnostics.push({ severity: "warning", source: candidate.path, message: content.diagnostic });
+    }
+    return {
+        ...candidate,
+        frontmatter: content.frontmatter,
+        body: content.body,
+        contentHash: content.contentHash,
+        matchReason: { kind: "no-match" },
+    };
+}
+function ruleDedupKey(rule) {
+    return `${rule.realPath}::${rule.contentHash}`;
+}
+function isCandidateWithinProject(candidate, projectRoot) {
+    if (candidate.isGlobal) {
+        return true;
+    }
+    if (projectRoot === null) {
+        return false;
+    }
+    const relativeRealPath = relative(realPathOrResolved(projectRoot), realPathOrResolved(candidate.realPath));
+    return relativeRealPath === "" || (!relativeRealPath.startsWith("..") && !isAbsolute(relativeRealPath));
+}
+function isCandidateWithinProjectCached(candidate, projectRoot, projectMembership) {
+    if (projectMembership === undefined) {
+        return isCandidateWithinProject(candidate, projectRoot);
+    }
+    const cacheKey = `${projectRoot ?? ""}\0${candidate.realPath}`;
+    const cached = projectMembership.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const isWithinProject = isCandidateWithinProject(candidate, projectRoot);
+    projectMembership.set(cacheKey, isWithinProject);
+    return isWithinProject;
+}
+function realPathOrResolved(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function findSortedCandidatesCached(cache, findCandidates, options) {
+    const cacheKey = candidateDiscoveryCacheKey(options);
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const candidates = sortCandidates(findCandidates(options));
+    cache.set(cacheKey, candidates);
+    return candidates;
+}
+function candidateDiscoveryCacheKey(options) {
+    return [
+        options.projectRoot ?? "",
+        options.targetFile === null ? "" : dirname(resolve(options.targetFile)),
+        ...[...(options.disabledSources ?? [])].sort(),
+    ].join("\0");
+}
+function isSameOrChildPath(childPath, parentPath) {
+    const childRelativePath = relative(parentPath, resolve(childPath));
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+function staticMatchReason(rule) {
+    if (rule.frontmatter.alwaysApply === true) {
+        return "alwaysApply";
+    }
+    if (rule.isSingleFile) {
+        return "single-file";
+    }
+    return null;
+}
+function disabledSourcesFor(config) {
+    if (config.enabledSources === "auto") {
+        return undefined;
+    }
+    const enabledSources = new Set(config.enabledSources);
+    return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
+}
+function isDedupedRootSingleFile(candidate, rootSingleFileSelected) {
+    return rootSingleFileSelected && isRootSingleFile(candidate);
+}
+function isRootSingleFile(candidate) {
+    return candidate.distance === 0 && candidate.isSingleFile && ROOT_SINGLE_FILE_SOURCES.has(candidate.source);
+}
+function pathBasesForTarget(projectRoot, targetFile, candidate) {
+    const targetBasename = basename(targetFile);
+    if (projectRoot === null) {
+        return { projectRelative: targetBasename, basename: targetBasename };
+    }
+    const projectRelative = toPosixPath(relative(projectRoot, targetFile));
+    const scopeDirectory = scopeDirectoryForCandidate(projectRoot, candidate);
+    if (scopeDirectory === null) {
+        return { projectRelative, basename: targetBasename };
+    }
+    return {
+        projectRelative,
+        scopeRelative: toPosixPath(relative(scopeDirectory, targetFile)),
+        basename: targetBasename,
+    };
+}
+function scopeDirectoryForCandidate(projectRoot, candidate) {
+    if (candidate.isGlobal) {
+        return null;
+    }
+    if (candidate.isSingleFile) {
+        return dirname(candidate.path);
+    }
+    const sourceIndex = candidate.relativePath.indexOf(candidate.source);
+    if (sourceIndex === -1) {
+        return projectRoot;
+    }
+    const scopeRelativeDirectory = candidate.relativePath.slice(0, sourceIndex).replace(/\/$/, "");
+    return scopeRelativeDirectory.length === 0 ? projectRoot : join(projectRoot, scopeRelativeDirectory);
+}
+function toPosixPath(path) {
+    return path.replaceAll("\\", "/");
+}
+function storeLastLoad(state, rules, diagnostics) {
+    state.loadedRules.length = 0;
+    state.loadedRules.push(...rules);
+    state.diagnostics.length = 0;
+    state.diagnostics.push(...diagnostics);
+}
+function emptyLoadResult(state) {
+    storeLastLoad(state, [], []);
+    return { rules: [], diagnostics: [] };
+}
+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/rules/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class UnsupportedRuleSourceError extends Error {
+    constructor(message: string);
+}
+export declare class RuleFrontmatterParseError extends Error {
+    constructor(message: string);
+}

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

@@ -0,0 +1,12 @@
+export class UnsupportedRuleSourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnsupportedRuleSourceError";
+    }
+}
+export class RuleFrontmatterParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RuleFrontmatterParseError";
+    }
+}

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

@@ -0,0 +1,14 @@
+import { scanRuleFiles } from "./scanner.js";
+type ScannedRuleFiles = ReturnType<typeof scanRuleFiles>;
+interface SingleFileInfo {
+    readonly path: string;
+    readonly realPath: string;
+}
+export interface RuleDiscoveryCache {
+    readonly scannedRuleFiles: Map<string, ScannedRuleFiles>;
+    readonly singleFileInfo: Map<string, SingleFileInfo | null>;
+}
+export declare function createRuleDiscoveryCache(): RuleDiscoveryCache;
+export declare function scanRuleFilesCached(rootDir: string, cache: RuleDiscoveryCache | undefined): ScannedRuleFiles;
+export declare function singleFileInfoCached(filePath: string, cache: RuleDiscoveryCache | undefined): SingleFileInfo | null;
+export {};

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

@@ -0,0 +1,51 @@
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { scanRuleFiles } from "./scanner.js";
+export function createRuleDiscoveryCache() {
+    return { scannedRuleFiles: new Map(), singleFileInfo: new Map() };
+}
+export function scanRuleFilesCached(rootDir, cache) {
+    if (cache === undefined) {
+        return scanRuleFiles({ rootDir });
+    }
+    const cached = cache.scannedRuleFiles.get(rootDir);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const scannedFiles = scanRuleFiles({ rootDir });
+    cache.scannedRuleFiles.set(rootDir, scannedFiles);
+    return scannedFiles;
+}
+export function singleFileInfoCached(filePath, cache) {
+    if (cache === undefined) {
+        return readSingleFileInfo(filePath);
+    }
+    const cached = cache.singleFileInfo.get(filePath);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const fileInfo = readSingleFileInfo(filePath);
+    cache.singleFileInfo.set(filePath, fileInfo);
+    return fileInfo;
+}
+function readSingleFileInfo(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        if (!statSync(filePath).isFile()) {
+            return null;
+        }
+        return { path: filePath, realPath: resolveRealPath(filePath) };
+    }
+    catch {
+        return null;
+    }
+}
+function resolveRealPath(filePath) {
+    try {
+        return realpathSync.native(filePath);
+    }
+    catch {
+        return filePath;
+    }
+}

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

@@ -0,0 +1,6 @@
+export interface WalkDirectory {
+    readonly directory: string;
+    readonly distance: number;
+}
+export declare function getWalkDirectories(projectRoot: string, targetFile: string | null): WalkDirectory[];
+export declare function toRelativePath(rootDirectory: string, filePath: string): string;

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

@@ -0,0 +1,33 @@
+import { dirname, posix, relative, resolve } from "node:path";
+export function getWalkDirectories(projectRoot, targetFile) {
+    if (targetFile === null) {
+        return [{ directory: projectRoot, distance: 0 }];
+    }
+    const startDirectory = dirname(resolve(targetFile));
+    if (!isSameOrChildPath(startDirectory, projectRoot)) {
+        return [{ directory: projectRoot, distance: 0 }];
+    }
+    const walkDirectories = [];
+    let currentDirectory = startDirectory;
+    let distance = 0;
+    while (true) {
+        walkDirectories.push({ directory: currentDirectory, distance });
+        if (currentDirectory === projectRoot) {
+            break;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            break;
+        }
+        currentDirectory = parentDirectory;
+        distance += 1;
+    }
+    return walkDirectories;
+}
+export function toRelativePath(rootDirectory, filePath) {
+    return posix.normalize(relative(rootDirectory, filePath).replace(/\\/g, "/"));
+}
+function isSameOrChildPath(childPath, parentPath) {
+    const childRelativePath = relative(parentPath, childPath);
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !childRelativePath.startsWith("/"));
+}

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

@@ -0,0 +1,5 @@
+import type { RuleSource } from "./types.js";
+export declare function toProjectRuleSource(parentDirectory: string, subDirectory: string): RuleSource;
+export declare function toProjectSingleFileSource(ruleFile: string): RuleSource;
+export declare function toUserHomeRuleSource(ruleSubdir: string): RuleSource;
+export declare function toUserHomeSingleFileSource(ruleFile: string): RuleSource;

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

@@ -0,0 +1,45 @@
+import { UnsupportedRuleSourceError } from "./errors.js";
+export function toProjectRuleSource(parentDirectory, subDirectory) {
+    const source = `${parentDirectory}/${subDirectory}`;
+    switch (source) {
+        case ".omo/rules":
+        case ".claude/rules":
+        case ".cursor/rules":
+        case ".github/instructions":
+            return source;
+        default:
+            throw new UnsupportedRuleSourceError(`Unsupported project rule source: ${source}`);
+    }
+}
+export function toProjectSingleFileSource(ruleFile) {
+    switch (ruleFile) {
+        case ".github/copilot-instructions.md":
+        case "AGENTS.md":
+        case "CLAUDE.md":
+        case "CONTEXT.md":
+            return ruleFile;
+        default:
+            throw new UnsupportedRuleSourceError(`Unsupported project single-file source: ${ruleFile}`);
+    }
+}
+export function toUserHomeRuleSource(ruleSubdir) {
+    const source = `~/${ruleSubdir}`;
+    switch (source) {
+        case "~/.omo/rules":
+        case "~/.opencode/rules":
+        case "~/.claude/rules":
+            return source;
+        default:
+            throw new UnsupportedRuleSourceError(`Unsupported user-home rule source: ${source}`);
+    }
+}
+export function toUserHomeSingleFileSource(ruleFile) {
+    const source = `~/${ruleFile}`;
+    switch (source) {
+        case "~/.config/opencode/AGENTS.md":
+        case "~/.claude/CLAUDE.md":
+            return source;
+        default:
+            throw new UnsupportedRuleSourceError(`Unsupported user-home single-file source: ${source}`);
+    }
+}

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

@@ -0,0 +1,26 @@
+import { type RuleDiscoveryCache } from "./finder-cache.js";
+import type { RuleCandidate } from "./types.js";
+export type { RuleDiscoveryCache } from "./finder-cache.js";
+export { createRuleDiscoveryCache } from "./finder-cache.js";
+export interface FinderOptions {
+    /** Project root absolute path (use findProjectRoot to get this). */
+    projectRoot: string | null;
+    /** Target file path (used for distance calculation in dynamic injection mode). null for static mode. */
+    targetFile: string | null;
+    /** User home directory (default: os.homedir()). Injectable for tests. */
+    homeDir?: string;
+    /** Set of disabled sources to omit from discovery. Empty by default. */
+    disabledSources?: ReadonlySet<string>;
+    /** Whether to skip user-home rules. Default: false. */
+    skipUserHome?: boolean;
+    /** Plugin root directory. Defaults to PLUGIN_ROOT env or this package root. */
+    pluginRoot?: string;
+    cache?: RuleDiscoveryCache;
+}
+interface PluginBundledFinderOptions {
+    readonly disabledSources?: ReadonlySet<string>;
+    readonly cache?: RuleDiscoveryCache;
+    readonly pluginRoot?: string;
+}
+export declare function findRuleCandidates(options: FinderOptions): RuleCandidate[];
+export declare function findPluginBundledCandidates(options?: PluginBundledFinderOptions): RuleCandidate[];