codictator 0.0.0 → 0.1.2

package/dist/features/packs/enforcers/health-lex-imports.js

@@ -0,0 +1,225 @@
+// SPEC §6.1: import/export specifier lexer. Word-boundary matching
+// with comment, string and template-hole skipping, so specifiers inside
+// strings, comments and fixture text never count. The packs module cannot
+// import the pack supplies (§3.3), so this mirrors the §6.1 supply lexer.
+import { isSpaceChar, readLiteral, skipQuoted } from "./health-lex.js";
+function isLexWordChar(code) {
+    return ((code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        (code >= 0x30 && code <= 0x39) ||
+        code === 0x5f ||
+        code === 0x24);
+}
+function wordAt(text, index, word) {
+    if (!text.startsWith(word, index)) {
+        return false;
+    }
+    const before = index === 0 ? Number.NaN : text.charCodeAt(index - 1);
+    if (!Number.isNaN(before) && isLexWordChar(before)) {
+        return false;
+    }
+    const after = text.charCodeAt(index + word.length);
+    return Number.isNaN(after) || !isLexWordChar(after);
+}
+function skipSpaceComments(text, index) {
+    let cursor = index;
+    while (cursor < text.length) {
+        const char = text.charAt(cursor);
+        if (isSpaceChar(char)) {
+            cursor += 1;
+            continue;
+        }
+        if (char === "/" && text.charAt(cursor + 1) === "/") {
+            while (cursor < text.length && text.charAt(cursor) !== "\n") {
+                cursor += 1;
+            }
+            continue;
+        }
+        if (char === "/" && text.charAt(cursor + 1) === "*") {
+            const close = text.indexOf("*/", cursor + 2);
+            cursor = close < 0 ? text.length : close + 2;
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+// SPEC §6.1: import and export specifiers read by a lexer, never a regex,
+// so specifiers inside strings, comments and template holes never count.
+// A non-literal dynamic target yields nothing; the caller treats it as
+// unresolvable instead of inventing a target.
+export function extractLiteralSpecifiers(text) {
+    const starts = [0];
+    for (let at = 0; at < text.length; at += 1) {
+        if (text.charAt(at) === "\n") {
+            starts.push(at + 1);
+        }
+    }
+    const lineOf = (at) => {
+        let low = 0;
+        let high = starts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if ((starts[mid] ?? 0) <= at) {
+                low = mid;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return low + 1;
+    };
+    const specs = [];
+    const pushLiteral = (at) => {
+        const found = readLiteral(text, at);
+        if (found !== undefined) {
+            specs.push({ spec: found.value, line: lineOf(at) });
+            return found.next;
+        }
+        return skipQuoted(text, at);
+    };
+    // One clause step: a string, `from` or `require` word either finishes
+    // the clause (done) or advances past itself. Undefined means no word
+    // matched and the brace scan continues.
+    const clauseString = (cursor, depth, sideEffect) => {
+        const char = text.charAt(cursor);
+        if (char !== '"' && char !== "'" && char !== "`") {
+            return undefined;
+        }
+        if (sideEffect && depth === 0) {
+            return { next: pushLiteral(cursor), done: true };
+        }
+        return { next: skipQuoted(text, cursor), done: false };
+    };
+    const clauseFrom = (cursor, depth) => {
+        if (!wordAt(text, cursor, "from") || depth !== 0) {
+            return undefined;
+        }
+        const after = skipSpaceComments(text, cursor + 4);
+        const found = readLiteral(text, after);
+        if (found !== undefined) {
+            specs.push({ spec: found.value, line: lineOf(after) });
+            return found.next;
+        }
+        return skipQuoted(text, after);
+    };
+    const clauseRequire = (cursor, depth) => {
+        if (!wordAt(text, cursor, "require") || depth !== 0) {
+            return undefined;
+        }
+        const call = skipSpaceComments(text, cursor + 7);
+        if (text.charAt(call) !== "(") {
+            return undefined;
+        }
+        const literal = readLiteral(text, skipSpaceComments(text, call + 1));
+        if (literal !== undefined) {
+            specs.push({ spec: literal.value, line: lineOf(cursor) });
+            return literal.next;
+        }
+        return call + 1;
+    };
+    // Brace and terminator scan for one clause position: advances past
+    // the character, tracks depth, or stops the clause.
+    const stepBrace = (cursor, depth) => {
+        const char = text.charAt(cursor);
+        if (char === "{") {
+            return { cursor: cursor + 1, depth: depth + 1, stop: false };
+        }
+        if (char === "}") {
+            return depth === 0
+                ? { cursor, depth, stop: true }
+                : { cursor: cursor + 1, depth: depth - 1, stop: false };
+        }
+        if (char === ";" ||
+            char === "(" ||
+            char === ")" ||
+            (char === "=" && text.charAt(cursor + 1) === ">")) {
+            return { cursor, depth, stop: true };
+        }
+        return { cursor: cursor + 1, depth, stop: false };
+    };
+    // A static `import`/`export` clause: the `from` specifier when one
+    // follows at brace depth zero, else the side-effect string for
+    // `import` (bare `export {...}` names no module).
+    const clause = (from, sideEffect) => {
+        let cursor = from;
+        let depth = 0;
+        let resume = from;
+        while (cursor < text.length) {
+            cursor = skipSpaceComments(text, cursor);
+            if (cursor >= text.length) {
+                break;
+            }
+            resume = cursor;
+            const stepped = clauseString(cursor, depth, sideEffect);
+            if (stepped !== undefined) {
+                if (stepped.done) {
+                    return stepped.next;
+                }
+                cursor = stepped.next;
+                continue;
+            }
+            const fromNext = clauseFrom(cursor, depth);
+            if (fromNext !== undefined) {
+                return fromNext;
+            }
+            const requireNext = clauseRequire(cursor, depth);
+            if (requireNext !== undefined) {
+                return requireNext;
+            }
+            const advanced = stepBrace(cursor, depth);
+            cursor = advanced.cursor;
+            depth = advanced.depth;
+            if (advanced.stop) {
+                break;
+            }
+        }
+        return resume + 1;
+    };
+    const scanImportWord = (index, isImport) => {
+        const after = skipSpaceComments(text, index + (isImport ? 6 : 7));
+        if (text.charAt(after) === "." && isImport) {
+            return after + 1;
+        }
+        if (text.charAt(after) === "(") {
+            const literal = readLiteral(text, skipSpaceComments(text, after + 1));
+            if (literal !== undefined) {
+                specs.push({ spec: literal.value, line: lineOf(after + 1) });
+                return literal.next;
+            }
+            return after + 1;
+        }
+        return clause(after, isImport);
+    };
+    let index = 0;
+    while (index < text.length) {
+        const char = text.charAt(index);
+        if (char === '"' || char === "'" || char === "`") {
+            index = skipQuoted(text, index);
+            continue;
+        }
+        if (char === "/" && text.charAt(index + 1) === "/") {
+            while (index < text.length && text.charAt(index) !== "\n") {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && text.charAt(index + 1) === "*") {
+            const close = text.indexOf("*/", index + 2);
+            index = close < 0 ? text.length : close + 2;
+            continue;
+        }
+        const isImport = char === "i" && wordAt(text, index, "import");
+        const isRequire = char === "r" && wordAt(text, index, "require");
+        if (isImport || isRequire) {
+            index = scanImportWord(index, isImport);
+            continue;
+        }
+        if (char === "e" && wordAt(text, index, "export")) {
+            index = clause(skipSpaceComments(text, index + 6), false);
+            continue;
+        }
+        index += 1;
+    }
+    return specs;
+}

package/dist/features/packs/enforcers/health-lex-template.d.ts

@@ -0,0 +1,10 @@
+export type LexState = "code" | "line" | "block" | "sq" | "dq" | "tpl";
+export interface LexScan {
+    index: number;
+    state: LexState;
+    braceDepth: number;
+    templateTops: Array<number>;
+}
+export declare function stepEscape(text: string, out: Array<string>, scan: LexScan, blank: boolean): void;
+export declare function stepCodeBrace(text: string, scan: LexScan): void;
+export declare function stepTemplate(text: string, out: Array<string>, scan: LexScan, blank: boolean): void;

package/dist/features/packs/enforcers/health-lex-template.js

@@ -0,0 +1,67 @@
+export function stepEscape(text, out, scan, blank) {
+    if (blank) {
+        out[scan.index] = " ";
+        if (scan.index + 1 < text.length && text.charAt(scan.index + 1) !== "\n") {
+            out[scan.index + 1] = " ";
+        }
+    }
+    scan.index += 2;
+}
+// Brace depth tracks `${` holes: a `}` that returns to the depth a hole
+// opened at closes the hole, so the template literal resumes. Stray
+// closers floor at zero instead of opening a hole that never existed.
+// Braces stay readable because code state never blanks.
+export function stepCodeBrace(text, scan) {
+    const char = text.charAt(scan.index);
+    if (char === "{") {
+        scan.braceDepth += 1;
+        scan.index += 1;
+        return;
+    }
+    if (char !== "}") {
+        scan.index += 1;
+        return;
+    }
+    scan.braceDepth -= 1;
+    if (scan.braceDepth < 0) {
+        scan.braceDepth = 0;
+    }
+    const top = scan.templateTops[scan.templateTops.length - 1];
+    if (top !== undefined && scan.braceDepth === top) {
+        scan.templateTops.pop();
+        scan.state = "tpl";
+    }
+    scan.index += 1;
+}
+// Template bodies blank as string content, but `${` holes hold code:
+// the opener stays so the hole reads as code, and the `}` that returns
+// to the opening depth resumes the literal. The ts/lint unused-binding
+// check counts words over blanked output, so a binding used only inside
+// a hole would read as unused without this; it mirrors the TypeScript
+// supply lexer (SPEC §6.1), so both blankCode implementations agree.
+export function stepTemplate(text, out, scan, blank) {
+    const char = text.charAt(scan.index);
+    if (char === "\\") {
+        stepEscape(text, out, scan, blank);
+        return;
+    }
+    if (char === "$" && text.charAt(scan.index + 1) === "{") {
+        scan.templateTops.push(scan.braceDepth);
+        scan.braceDepth += 1;
+        scan.state = "code";
+        scan.index += 2;
+        return;
+    }
+    if (char === "`") {
+        if (blank) {
+            out[scan.index] = " ";
+        }
+        scan.index += 1;
+        scan.state = "code";
+        return;
+    }
+    if (blank && char !== "\n") {
+        out[scan.index] = " ";
+    }
+    scan.index += 1;
+}

package/dist/features/packs/enforcers/health-lex.d.ts

@@ -0,0 +1,8 @@
+export declare function blankCode(text: string): string;
+export declare function blankComments(text: string): string;
+export declare function isSpaceChar(char: string): boolean;
+export declare function skipQuoted(text: string, index: number): number;
+export declare function readLiteral(text: string, index: number): {
+    readonly value: string;
+    readonly next: number;
+} | undefined;

package/dist/features/packs/enforcers/health-lex.js

@@ -0,0 +1,227 @@
+// SPEC §6.1 lexing: comment and string blanking shared by the pack
+// enforcers. Char-for-char, so every index still maps to the original line.
+// Char-for-char blanking of comments and strings: keywords inside them
+// never count, and every index still maps to the original line.
+// Template scanning lives in health-lex-template.ts; blanking here stays
+// in one pass over the shared scan state.
+import { stepCodeBrace, stepEscape, stepTemplate, } from "./health-lex-template.js";
+function copyChars(text) {
+    const out = new Array(text.length);
+    for (let index = 0; index < text.length; index += 1) {
+        out[index] = text.charAt(index);
+    }
+    return out;
+}
+function quoteStateFor(char) {
+    if (char === "'") {
+        return "sq";
+    }
+    if (char === '"') {
+        return "dq";
+    }
+    if (char === "`") {
+        return "tpl";
+    }
+    return undefined;
+}
+function isQuoteCloser(state, char) {
+    if (state === "sq") {
+        return char === "'";
+    }
+    if (state === "dq") {
+        return char === '"';
+    }
+    return char === "`";
+}
+// Comment openers blank in both modes; the caller decides about quotes.
+function stepCodeComment(text, out, scan) {
+    const char = text.charAt(scan.index);
+    const next = text.charAt(scan.index + 1);
+    if (char === "/" && next === "/") {
+        scan.state = "line";
+        out[scan.index] = " ";
+        out[scan.index + 1] = " ";
+        scan.index += 2;
+        return true;
+    }
+    if (char === "/" && next === "*") {
+        scan.state = "block";
+        out[scan.index] = " ";
+        out[scan.index + 1] = " ";
+        scan.index += 2;
+        return true;
+    }
+    return false;
+}
+function stepCodeQuote(text, out, scan, blank) {
+    const opened = quoteStateFor(text.charAt(scan.index));
+    if (opened === undefined) {
+        return false;
+    }
+    scan.state = opened;
+    if (blank) {
+        out[scan.index] = " ";
+    }
+    scan.index += 1;
+    return true;
+}
+function stepLineComment(out, scan, char) {
+    if (char === "\n") {
+        scan.state = "code";
+    }
+    else {
+        out[scan.index] = " ";
+    }
+    scan.index += 1;
+}
+function stepBlockComment(out, scan, char, next) {
+    if (char === "*" && next === "/") {
+        out[scan.index] = " ";
+        out[scan.index + 1] = " ";
+        scan.index += 2;
+        scan.state = "code";
+        return;
+    }
+    if (char !== "\n") {
+        out[scan.index] = " ";
+    }
+    scan.index += 1;
+}
+function stepQuoted(text, out, scan, char, blank) {
+    if (char === "\\") {
+        stepEscape(text, out, scan, blank);
+        return;
+    }
+    if (blank && char !== "\n") {
+        out[scan.index] = " ";
+    }
+    scan.index += 1;
+    if (isQuoteCloser(scan.state, char)) {
+        scan.state = "code";
+    }
+}
+// One pass over the text; comment openers always blank, string
+// contents blank only for blankCode. Template holes (`${ ... }`) scan
+// as code, so identifiers used only inside a hole still count.
+function runBlank(text, blankStrings) {
+    const out = copyChars(text);
+    const scan = {
+        index: 0,
+        state: "code",
+        braceDepth: 0,
+        templateTops: [],
+    };
+    while (scan.index < text.length) {
+        const char = text.charAt(scan.index);
+        const next = text.charAt(scan.index + 1);
+        if (scan.state === "code") {
+            if (stepCodeComment(text, out, scan)) {
+                continue;
+            }
+            if (stepCodeQuote(text, out, scan, blankStrings)) {
+                continue;
+            }
+            stepCodeBrace(text, scan);
+            continue;
+        }
+        if (scan.state === "tpl") {
+            stepTemplate(text, out, scan, blankStrings);
+            continue;
+        }
+        if (scan.state === "line") {
+            stepLineComment(out, scan, char);
+            continue;
+        }
+        if (scan.state === "block") {
+            stepBlockComment(out, scan, char, next);
+            continue;
+        }
+        stepQuoted(text, out, scan, char, blankStrings);
+    }
+    return out.join("");
+}
+export function blankCode(text) {
+    return runBlank(text, true);
+}
+// Comment-only blanking: strings survive so import specifiers stay
+// readable while commented-out imports never count.
+export function blankComments(text) {
+    return runBlank(text, false);
+}
+// Word match with boundaries on both sides, so `required` never reads as
+// `require` and `important` never reads as `import`.
+export function isSpaceChar(char) {
+    return (char === " " ||
+        char === "\t" ||
+        char === "\n" ||
+        char === "\r" ||
+        char === "\v" ||
+        char === "\f" ||
+        char === "\u00a0");
+}
+// Skip a quoted region; a template holding `${}` is skipped whole, so
+// code inside holes never reads as top-level code.
+export function skipQuoted(text, index) {
+    const quote = text.charAt(index);
+    let cursor = index + 1;
+    let depth = 0;
+    while (cursor < text.length) {
+        const char = text.charAt(cursor);
+        if (char === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (quote === "`") {
+            if (char === "$" && text.charAt(cursor + 1) === "{") {
+                depth += 1;
+                cursor += 2;
+                continue;
+            }
+            if (char === "}" && depth > 0) {
+                depth -= 1;
+                cursor += 1;
+                continue;
+            }
+        }
+        if (char === quote && depth === 0) {
+            return cursor + 1;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+// Read a literal specifier; a template holding `${}` is not a literal, so
+// the caller reports it unresolvable instead of inventing a target.
+export function readLiteral(text, index) {
+    const quote = text.charAt(index);
+    if (quote !== "'" && quote !== '"' && quote !== "`") {
+        return undefined;
+    }
+    if (quote === "`") {
+        const end = skipQuoted(text, index);
+        const body = text.slice(index + 1, end - 1);
+        if (body.includes("${")) {
+            return undefined;
+        }
+        return { value: body, next: end };
+    }
+    let value = "";
+    let cursor = index + 1;
+    while (cursor < text.length) {
+        const char = text.charAt(cursor);
+        if (char === "\\" && cursor + 1 < text.length) {
+            value += text.charAt(cursor + 1);
+            cursor += 2;
+            continue;
+        }
+        if (char === quote) {
+            return { value, next: cursor + 1 };
+        }
+        if (char === "\n") {
+            return undefined;
+        }
+        value += char;
+        cursor += 1;
+    }
+    return undefined;
+}

package/dist/features/packs/enforcers/health-markers.d.ts

@@ -0,0 +1,3 @@
+export declare function isMarkerFile(path: string): boolean;
+export declare function parseMarkers(text: string): Map<string, string>;
+export declare function parseMarkerInt(markers: Map<string, string>, key: string): number | undefined;

package/dist/features/packs/enforcers/health-markers.js

@@ -0,0 +1,31 @@
+// SPEC §4.4.1: fixture measure-report markers. Sample files
+// (`sample.txt`) carry `key: value` lines the marker enforcers honour;
+// violating fixtures flag and passing fixtures stay clean. Split from the
+// measures (health-measures) by responsibility: markers here, spans and
+// counts there.
+export function isMarkerFile(path) {
+    return path === "sample.txt" || path.endsWith("/sample.txt");
+}
+export function parseMarkers(text) {
+    const markers = new Map();
+    for (const line of text.split("\n")) {
+        const colon = line.indexOf(":");
+        if (colon < 0) {
+            continue;
+        }
+        const key = line.slice(0, colon).trim().toLowerCase();
+        const value = line.slice(colon + 1).trim();
+        if (key.length > 0) {
+            markers.set(key, value);
+        }
+    }
+    return markers;
+}
+export function parseMarkerInt(markers, key) {
+    const raw = markers.get(key);
+    if (raw === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isInteger(parsed) ? parsed : undefined;
+}

package/dist/features/packs/enforcers/health-measures.d.ts

@@ -0,0 +1,24 @@
+import type { Ports } from "../../../kernel/index.ts";
+import type { CheckContext, Enforcer, Finding } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+import { type RuleBinding } from "./binding.ts";
+import { isMarkerFile, parseMarkerInt, parseMarkers } from "./health-markers.ts";
+export declare function countCyclomatic(blanked: string): number;
+export interface FunctionSpan {
+    readonly line: number;
+    readonly lines: number;
+}
+export declare function measureFunctionSpans(text: string): Array<FunctionSpan>;
+export declare function loadScopeText(ports: Ports, binding: RuleBinding, file: string, findings: Array<Finding>): Promise<string | undefined>;
+export declare function scopeMarkerTexts(ports: Ports, binding: RuleBinding, ctx: CheckContext, findings: Array<Finding>): Promise<Array<{
+    readonly file: string;
+    readonly markers: Map<string, string>;
+}>>;
+export declare function baseEnforcer(rule: PackRule, binding: RuleBinding, decl: EnforcerDecl, check: (ctx: CheckContext) => Promise<Array<Finding>>): Enforcer;
+export declare function limitOf(binding: RuleBinding, name: string, fallback: number): number;
+export { isMarkerFile, parseMarkerInt, parseMarkers };
+export declare function isTsFile(path: string): boolean;
+export declare function exportedNamesOf(blanked: string): Array<string>;
+export declare function isEntryFile(path: string): boolean;
+export declare function fileImportsTarget(importing: string, target: string): boolean;