@litfamily/litopencode 1.0.0

package/dist/rules/frontmatter.js

@@ -0,0 +1,179 @@
+import { expandBraces } from "./glob.js";
+const yaml = await import("yaml").catch(() => undefined);
+export const ruleScopeLimits = Object.freeze({
+    maxGlobs: 64,
+    maxGlobCharacters: 512
+});
+const emptyFrontmatter = {
+    description: "",
+    globs: [],
+    scopeDeclared: false,
+    alwaysApply: undefined,
+    malformed: false
+};
+const scopeKeys = new Set(["globs", "applyto", "paths"]);
+function extractFrontmatter(text) {
+    const firstBreak = text.indexOf("\n");
+    if (firstBreak === -1 || text.slice(0, firstBreak).replace(/\r$/u, "") !== "---")
+        return undefined;
+    let cursor = firstBreak + 1;
+    while (cursor <= text.length) {
+        const nextBreak = text.indexOf("\n", cursor);
+        const lineEnd = nextBreak === -1 ? text.length : nextBreak;
+        if (text.slice(cursor, lineEnd).replace(/\r$/u, "") === "---") {
+            return {
+                block: text.slice(firstBreak + 1, cursor),
+                body: nextBreak === -1 ? "" : text.slice(nextBreak + 1).trim(),
+                terminated: true
+            };
+        }
+        if (nextBreak === -1)
+            break;
+        cursor = nextBreak + 1;
+    }
+    return { block: text.slice(firstBreak + 1), body: text.trim(), terminated: false };
+}
+function scalarKey(pair, parser) {
+    if (!parser.isScalar(pair.key) || typeof pair.key.value !== "string")
+        return undefined;
+    return pair.key.value.toLowerCase();
+}
+function lexicalTopLevelScope(block) {
+    return block.split(/\r?\n/u).some((line) => /^(?:globs|applyTo|paths)\s*:/iu.test(line));
+}
+function splitPlainList(value) {
+    const parts = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character === "{")
+            braceDepth += 1;
+        else if (character === "}") {
+            if (braceDepth === 0)
+                return undefined;
+            braceDepth -= 1;
+        }
+        else if (character === "[")
+            bracketDepth += 1;
+        else if (character === "]") {
+            if (bracketDepth === 0)
+                return undefined;
+            bracketDepth -= 1;
+        }
+        else if (character === "," && braceDepth === 0 && bracketDepth === 0) {
+            const part = value.slice(start, index).trim();
+            if (part === "")
+                return undefined;
+            parts.push(part);
+            start = index + 1;
+        }
+    }
+    if (braceDepth !== 0 || bracketDepth !== 0)
+        return undefined;
+    const tail = value.slice(start).trim();
+    if (tail === "")
+        return undefined;
+    parts.push(tail);
+    return parts;
+}
+function scopeNodeValues(key, node, parser) {
+    if (parser.isSeq(node)) {
+        const values = [];
+        for (const item of node.items) {
+            if (!parser.isScalar(item) || typeof item.value !== "string" || item.value.trim() === "")
+                return undefined;
+            values.push(item.value.trim());
+        }
+        return values;
+    }
+    if (!parser.isScalar(node) || typeof node.value !== "string" || node.value.trim() === "")
+        return undefined;
+    const value = node.value.trim();
+    const splitScalar = key === "applyto" || node.type === "PLAIN";
+    return splitScalar ? splitPlainList(value) : [value];
+}
+function parseAlwaysApply(node, parser) {
+    if (!parser.isScalar(node))
+        return undefined;
+    if (typeof node.value === "boolean")
+        return node.value;
+    if (typeof node.value !== "string")
+        return undefined;
+    const value = node.value.trim().toLowerCase();
+    if (value === "true" || value === "yes")
+        return true;
+    if (value === "false" || value === "no")
+        return false;
+    return undefined;
+}
+function validGlobList(globs) {
+    if (globs.length === 0 || globs.length > ruleScopeLimits.maxGlobs)
+        return false;
+    for (const glob of globs) {
+        if (glob.length > ruleScopeLimits.maxGlobCharacters)
+            return false;
+        try {
+            expandBraces(glob);
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+export function parseRuleFile(text) {
+    const extracted = extractFrontmatter(text);
+    if (extracted === undefined)
+        return { frontmatter: emptyFrontmatter, body: text.trim() };
+    // Keep the package entry importable for the existing pre-install tarball probe. Normal consumers
+    // receive yaml through dependencies; if it is absent, frontmatter fails closed instead of turning a
+    // declared scope into repository-wide guidance.
+    if (yaml === undefined) {
+        return {
+            frontmatter: { ...emptyFrontmatter, scopeDeclared: true, malformed: true },
+            body: extracted.body
+        };
+    }
+    const document = yaml.parseDocument(extracted.block, { strict: true, uniqueKeys: true });
+    const pairs = yaml.isMap(document.contents) ? document.contents.items : [];
+    const scopePairs = pairs.filter((pair) => {
+        const key = scalarKey(pair, yaml);
+        return key !== undefined && scopeKeys.has(key);
+    });
+    const scopeDeclared = scopePairs.length > 0 || lexicalTopLevelScope(extracted.block);
+    let malformed = document.errors.length > 0 || !extracted.terminated;
+    let description = "";
+    let alwaysApply;
+    const collected = [];
+    for (const pair of pairs) {
+        const key = scalarKey(pair, yaml);
+        if (key === "description" && yaml.isScalar(pair.value) && pair.value.value !== null) {
+            description = String(pair.value.value);
+        }
+        else if (key === "alwaysapply") {
+            alwaysApply = parseAlwaysApply(pair.value, yaml);
+        }
+        else if (key !== undefined && scopeKeys.has(key)) {
+            const values = scopeNodeValues(key, pair.value, yaml);
+            if (values === undefined)
+                malformed = true;
+            else
+                collected.push(...values);
+        }
+    }
+    const globs = Object.freeze([...new Set(collected)]);
+    if (scopeDeclared && !validGlobList(globs))
+        malformed = true;
+    return {
+        frontmatter: {
+            description,
+            globs: malformed && scopeDeclared ? [] : globs,
+            scopeDeclared,
+            alwaysApply,
+            malformed
+        },
+        body: extracted.body
+    };
+}

package/dist/rules/glob.d.ts

@@ -0,0 +1,12 @@
+export declare const globComplexityLimits: Readonly<{
+    maxPatterns: 64;
+    maxPatternCharacters: 512;
+    maxBraceDepth: 16;
+    maxBraceExpansions: 256;
+}>;
+export type GlobMatcher = (candidatePath: string) => boolean;
+export declare function normalizeRelativePath(candidatePath: string): string;
+export declare function expandBraces(pattern: string): readonly string[];
+export declare function globRegexSource(pattern: string): string;
+export declare function matchGlob(pattern: string, candidatePath: string): boolean;
+export declare function createGlobMatcher(patterns: readonly string[]): GlobMatcher;

package/dist/rules/glob.js

@@ -0,0 +1,233 @@
+// Hand-rolled glob matcher for repository rule scoping.
+//
+// This engine ships with zero runtime dependencies, so the `.cursor/rules` glob dialect is
+// implemented here rather than vendored. The supported subset is deliberate: `**`, `*`, `?`,
+// `{a,b}` (nested), `[seq]` / `[!seq]`, and a leading `!` negation. Extglobs (`@(a|b)`, `!(a)`,
+// `+(a)`, `*(a)`, `?(a)`), POSIX classes, and backslash escaping are NOT supported, because rule
+// authors do not use them and every one of them costs correctness elsewhere.
+//
+// Divergences from picomatch are measured, not asserted: tools/run-rules-glob-differential.mjs
+// compiles the same corpus through both and writes the comparison to evidence. A written list is a
+// claim; the harness is the proof.
+const globCacheLimit = 512;
+const globCache = new Map();
+export const globComplexityLimits = Object.freeze({
+    maxPatterns: 64,
+    maxPatternCharacters: 512,
+    maxBraceDepth: 16,
+    maxBraceExpansions: 256
+});
+// A pattern is a directory anchor when it ends in `/`: `src/` scopes the whole subtree.
+function normalizePattern(pattern) {
+    let value = pattern.trim().replace(/\\/gu, "/");
+    while (value.startsWith("./"))
+        value = value.slice(2);
+    if (value.startsWith("/"))
+        value = value.slice(1);
+    if (value.endsWith("/"))
+        value = `${value}**`;
+    // `src/**/**` and `src/**` mean the same subtree; collapsing keeps the trailing-globstar rule below
+    // from seeing a doubled tail.
+    return value.replace(/(?:\/\*\*)+$/u, "/**");
+}
+export function normalizeRelativePath(candidatePath) {
+    let value = candidatePath.trim().replace(/\\/gu, "/");
+    while (value.startsWith("./"))
+        value = value.slice(2);
+    if (value.startsWith("/"))
+        value = value.slice(1);
+    return value;
+}
+// Brace expansion runs before regex translation so `{a,b}` never has to be expressed as an
+// alternation inside the compiled pattern, where a nested comma would be ambiguous.
+function expandBracesInto(pattern, recursionDepth, expanded) {
+    if (recursionDepth > globComplexityLimits.maxBraceDepth)
+        throw new RangeError("brace expansion limit exceeded: nesting depth");
+    const open = pattern.indexOf("{");
+    if (open === -1) {
+        if (expanded.length >= globComplexityLimits.maxBraceExpansions) {
+            throw new RangeError("brace expansion limit exceeded: alternatives");
+        }
+        expanded.push(pattern);
+        return;
+    }
+    let depth = 0;
+    let close = -1;
+    const alternatives = [];
+    let current = "";
+    for (let index = open; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "{") {
+            depth += 1;
+            if (depth === 1)
+                continue;
+        }
+        else if (character === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                close = index;
+                alternatives.push(current);
+                break;
+            }
+        }
+        else if (character === "," && depth === 1) {
+            alternatives.push(current);
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    // An unbalanced brace is a literal brace, matching how rule authors actually write paths.
+    if (close === -1) {
+        if (expanded.length >= globComplexityLimits.maxBraceExpansions) {
+            throw new RangeError("brace expansion limit exceeded: alternatives");
+        }
+        expanded.push(pattern);
+        return;
+    }
+    const prefix = pattern.slice(0, open);
+    const suffix = pattern.slice(close + 1);
+    for (const alternative of alternatives)
+        expandBracesInto(`${prefix}${alternative}${suffix}`, recursionDepth + 1, expanded);
+}
+export function expandBraces(pattern) {
+    if (pattern.length > globComplexityLimits.maxPatternCharacters) {
+        throw new RangeError("brace expansion limit exceeded: pattern length");
+    }
+    const expanded = [];
+    expandBracesInto(pattern, 0, expanded);
+    return expanded;
+}
+function escapeLiteral(character) {
+    return /[.+^$(){}|[\]\\]/u.test(character) ? `\\${character}` : character;
+}
+function translateCharacterClass(pattern, start) {
+    let index = start + 1;
+    let negated = false;
+    if (pattern[index] === "!" || pattern[index] === "^") {
+        negated = true;
+        index += 1;
+    }
+    let body = "";
+    // A `]` immediately after the opening bracket is a literal `]`.
+    if (pattern[index] === "]") {
+        body += "\\]";
+        index += 1;
+    }
+    while (index < pattern.length && pattern[index] !== "]") {
+        const character = pattern[index];
+        body += character === "\\" ? "\\\\" : character === "[" ? "\\[" : character;
+        index += 1;
+    }
+    if (index >= pattern.length)
+        return undefined;
+    if (body === "")
+        return undefined;
+    return { source: `[${negated ? "^" : ""}${body}]`, next: index + 1 };
+}
+export function globRegexSource(pattern) {
+    let value = normalizePattern(pattern);
+    // A trailing `/**` covers the directory itself as well as everything under it, so `src/**` matches
+    // `src`. Measured against picomatch 4.0.5, which agrees.
+    const trailingSubtree = value.endsWith("/**");
+    if (trailingSubtree)
+        value = value.slice(0, -3);
+    let source = "";
+    let index = 0;
+    while (index < value.length) {
+        const character = value[index];
+        if (character === "*") {
+            const doubled = value[index + 1] === "*";
+            if (doubled) {
+                const beforeIsBoundary = index === 0 || value[index - 1] === "/";
+                const afterSlash = value[index + 2] === "/";
+                const atEnd = index + 2 >= value.length;
+                if (beforeIsBoundary && afterSlash) {
+                    // `**/` spans zero or more whole segments.
+                    source += "(?:[^/]*/)*";
+                    index += 3;
+                    continue;
+                }
+                if (beforeIsBoundary && atEnd) {
+                    // A trailing `**` spans the rest of the path, including nothing at all.
+                    source += ".*";
+                    index += 2;
+                    continue;
+                }
+                // A `**` that is not segment-aligned degrades to `*`, which is what picomatch does too.
+                source += "[^/]*";
+                index += 2;
+                continue;
+            }
+            source += "[^/]*";
+            index += 1;
+            continue;
+        }
+        if (character === "?") {
+            source += "[^/]";
+            index += 1;
+            continue;
+        }
+        if (character === "[") {
+            const translated = translateCharacterClass(value, index);
+            if (translated !== undefined) {
+                source += translated.source;
+                index = translated.next;
+                continue;
+            }
+            source += "\\[";
+            index += 1;
+            continue;
+        }
+        source += escapeLiteral(character);
+        index += 1;
+    }
+    return `^${source}${trailingSubtree ? "(?:/.*)?" : ""}$`;
+}
+function compile(pattern) {
+    const cached = globCache.get(pattern);
+    if (cached !== undefined)
+        return cached;
+    let sources;
+    try {
+        sources = expandBraces(pattern).map(globRegexSource);
+    }
+    catch {
+        return undefined;
+    }
+    // A `/**` suffix should also match the directory itself, so `src/**` covers `src`.
+    const compiled = new RegExp(sources.map((source) => `(?:${source})`).join("|"), "u");
+    if (globCache.size >= globCacheLimit)
+        globCache.clear();
+    globCache.set(pattern, compiled);
+    return compiled;
+}
+export function matchGlob(pattern, candidatePath) {
+    const trimmed = pattern.trim();
+    if (trimmed === "")
+        return false;
+    const negated = trimmed.startsWith("!");
+    const effective = negated ? trimmed.slice(1) : trimmed;
+    const matched = compile(effective)?.test(normalizeRelativePath(candidatePath)) ?? false;
+    return negated ? !matched : matched;
+}
+// A rule's scope is the whole pattern list: positives grant, negations veto. An all-negative list
+// is treated as "everything except", which is how .gitignore-shaped rule lists read.
+export function createGlobMatcher(patterns) {
+    if (patterns.length > globComplexityLimits.maxPatterns ||
+        patterns.some((pattern) => pattern.length > globComplexityLimits.maxPatternCharacters))
+        return () => false;
+    const cleaned = patterns.map((pattern) => pattern.trim()).filter((pattern) => pattern !== "");
+    if (cleaned.length === 0)
+        return () => false;
+    const negations = cleaned.filter((pattern) => pattern.startsWith("!"));
+    const positives = cleaned.filter((pattern) => !pattern.startsWith("!"));
+    return (candidatePath) => {
+        const normalized = normalizeRelativePath(candidatePath);
+        if (negations.some((pattern) => !matchGlob(pattern, normalized)))
+            return false;
+        if (positives.length === 0)
+            return true;
+        return positives.some((pattern) => matchGlob(pattern, normalized));
+    };
+}

package/dist/rules/hooks.d.ts

@@ -0,0 +1,25 @@
+export type RulesHookOptions = {
+    readonly projectRoot: string;
+    readonly homeDir?: string;
+    readonly bundledRulesDir?: string;
+    readonly outputStyle?: string;
+};
+export type SystemTransformInput = {
+    readonly sessionID?: string;
+};
+export type SystemTransformOutput = {
+    system: string[];
+};
+export declare function applyStaticRuleInjection(options: RulesHookOptions, input: SystemTransformInput, output: SystemTransformOutput): Promise<void>;
+export type CompactingInput = {
+    readonly sessionID: string;
+};
+export type CompactingOutput = {
+    context: string[];
+};
+export declare function applyCompactionRuleReset(input: CompactingInput, output: CompactingOutput): Promise<void>;
+export type DynamicRuleResult = {
+    readonly text: string;
+    readonly ruleCount: number;
+};
+export declare function dynamicRulesForPaths(options: RulesHookOptions, sessionId: string, mutatedPaths: readonly string[]): Promise<DynamicRuleResult>;

package/dist/rules/hooks.js

@@ -0,0 +1,75 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readerFacingCommunicationContract } from "../reader-facing-output.js";
+import { noteSessionCompacted, selectRules } from "./engine.js";
+import { readOutputStyleText } from "./output-style.js";
+export async function applyStaticRuleInjection(options, input, output) {
+    if (typeof input.sessionID !== "string" || input.sessionID.trim() === "")
+        return;
+    if (!Array.isArray(output.system))
+        return;
+    const selection = await selectRules({
+        lane: "static",
+        sessionId: input.sessionID,
+        projectRoot: options.projectRoot,
+        homeDir: options.homeDir,
+        bundledRulesDir: options.bundledRulesDir
+    });
+    if (selection.text !== "")
+        output.system.push(selection.text);
+    const styleText = await readOutputStyleText(options.outputStyle);
+    if (styleText !== "")
+        output.system.push(styleText);
+    for (let index = output.system.length - 1; index >= 0; index -= 1) {
+        if (output.system[index]?.trimEnd() === readerFacingCommunicationContract)
+            output.system.splice(index, 1);
+    }
+    output.system.push(readerFacingCommunicationContract);
+}
+// Compaction drops the earlier prompt, so the delivered set is cleared and rules become eligible
+// again on the next turn -- bounded by the re-injection budget.
+export async function applyCompactionRuleReset(input, output) {
+    if (typeof input.sessionID !== "string" || input.sessionID.trim() === "")
+        return;
+    const allowed = noteSessionCompacted(input.sessionID);
+    if (allowed && Array.isArray(output.context)) {
+        output.context.push("LitOpenCode: repository rules will be re-delivered after this compaction. Preserve any rule-derived constraints already agreed in this session.");
+    }
+}
+// The dynamic lane rides the post-edit hook, whose output.output the host already consumes -- proven
+// by the existing post-edit skill routing, not assumed.
+export async function dynamicRulesForPaths(options, sessionId, mutatedPaths) {
+    if (mutatedPaths.length === 0)
+        return { text: "", ruleCount: 0 };
+    const projectRoot = await fs.realpath(path.resolve(options.projectRoot));
+    const relativePaths = [];
+    for (const candidate of mutatedPaths) {
+        const resolved = path.isAbsolute(candidate) ? path.resolve(candidate) : path.resolve(projectRoot, candidate);
+        let canonical;
+        try {
+            canonical = await fs.realpath(resolved);
+        }
+        catch {
+            continue;
+        }
+        const canonicalRelative = path.relative(projectRoot, canonical);
+        if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(canonicalRelative))
+            continue;
+        relativePaths.push(canonicalRelative);
+    }
+    if (relativePaths.length === 0)
+        return { text: "", ruleCount: 0 };
+    // Discovery walks upward from the edited file, so a nested package's rules outrank the root's by
+    // directory distance.
+    const startDir = path.dirname(path.resolve(projectRoot, relativePaths[0] ?? "."));
+    const selection = await selectRules({
+        lane: "dynamic",
+        sessionId,
+        projectRoot,
+        startDir,
+        homeDir: options.homeDir,
+        bundledRulesDir: options.bundledRulesDir,
+        candidatePaths: relativePaths
+    });
+    return { text: selection.text, ruleCount: selection.selected.length };
+}

package/dist/rules/output-style.d.ts

@@ -0,0 +1 @@
+export declare function readOutputStyleText(styleId: string | undefined): Promise<string>;

package/dist/rules/output-style.js

@@ -0,0 +1,20 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Resolved relative to the compiled output at dist/rules/output-style.js — two levels up reaches
+// the package root, where output-styles/ lives (same resolution pattern as managed-skill-assets.ts
+// uses for its manifest, and activation-prompt-utils.ts uses for skills/).
+const outputStylesDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../output-styles");
+const validStyleIds = new Set(["asd-ste100", "asd-ste100-ko", "eli5", "eli5-ko"]);
+export async function readOutputStyleText(styleId) {
+    if (styleId === undefined || styleId === "" || styleId === "off")
+        return "";
+    if (!validStyleIds.has(styleId))
+        return "";
+    try {
+        return await fs.readFile(path.join(outputStylesDir, styleId + ".md"), "utf8");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/scientific-visualization-banner.d.ts

@@ -0,0 +1 @@
+export declare const scientificVisualizationBanner: string;

package/dist/scientific-visualization-banner.js

@@ -0,0 +1,2 @@
+import { activationProbe } from "./activation-probe.js";
+export const scientificVisualizationBanner = activationProbe("lit-scientific-visualization");

package/dist/search-workflow-ideas.d.ts

@@ -0,0 +1,67 @@
+export type LitOpenCodeSearchWorkflowIdeaId = "public-route-fallback" | "access-verdicts" | "ssrf-boundary" | "evidence-trace" | "fetch-attempt-verdict-schema" | "positive-proof" | "claim-graph" | "ab-regression-sweep";
+export type LitOpenCodeSearchWorkflowIdea = {
+    readonly id: LitOpenCodeSearchWorkflowIdeaId;
+    readonly title: string;
+    readonly summary: string;
+    readonly steps: readonly string[];
+    readonly safety: readonly string[];
+    readonly verification: readonly string[];
+};
+export declare const litOpenCodeSearchWorkflowIdeas: readonly ({
+    id: "public-route-fallback";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "access-verdicts";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "ssrf-boundary";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "fetch-attempt-verdict-schema";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "evidence-trace";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "positive-proof";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "claim-graph";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+} | {
+    id: "ab-regression-sweep";
+    title: string;
+    summary: string;
+    steps: string[];
+    safety: string[];
+    verification: string[];
+})[];
+export declare function findLitOpenCodeSearchWorkflowIdea(id: string): LitOpenCodeSearchWorkflowIdea | undefined;