codictator 0.0.0 → 0.1.2

package/dist/builtin-packs/typescript/lex.ts

@@ -0,0 +1,199 @@
+// SPEC §4.11.3 + §6.1: shared lexical helpers for the TypeScript supplies.
+// Comment and string blanking keeps every offset and newline stable, so the
+// measures map findings back to source lines without a compiler API (the
+// zero-deps rule for packages/codictator forbids the TypeScript compiler).
+
+// SPEC §6.1 file naming: the extensions the TypeScript pack judges.
+export const TYPESCRIPT_SOURCE_EXTENSIONS: ReadonlyArray<string> = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts",
+];
+
+export function isTypeScriptFile(path: string): boolean {
+	const lowered = path.toLowerCase();
+	return TYPESCRIPT_SOURCE_EXTENSIONS.some((extension) =>
+		lowered.endsWith(extension),
+	);
+}
+
+// SPEC §4.11 EC-13: Windows separators normalise before resolution.
+export function toPosixPath(path: string): string {
+	return path.split("\\").join("/");
+}
+
+// Line starts for mapping an offset back to a 1-based line.
+export function lineStartsFor(text: string): Array<number> {
+	const starts: Array<number> = [0];
+	for (let index = 0; index < text.length; index += 1) {
+		if (text.charAt(index) === "\n") {
+			starts.push(index + 1);
+		}
+	}
+	return starts;
+}
+
+// Binary search over the starts table; the result is 1-based.
+export function lineAtIndex(
+	starts: ReadonlyArray<number>,
+	index: number,
+): number {
+	let low = 0;
+	let high = starts.length - 1;
+	let line = 1;
+	while (low <= high) {
+		const mid = (low + high) >> 1;
+		const start = starts[mid] ?? 0;
+		if (start <= index) {
+			line = mid + 1;
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+	return line;
+}
+
+interface BlankState {
+	readonly out: Array<string>;
+	index: number;
+	state: "code" | "line" | "block" | "string";
+	quote: string;
+	depth: number;
+	readonly templateTops: Array<number>;
+}
+
+function pushNewlineOrSpace(state: BlankState, char: string): void {
+	state.out.push(char === "\n" ? "\n" : " ");
+	state.index += 1;
+}
+
+function stepLineComment(state: BlankState, char: string): void {
+	if (char === "\n") {
+		state.state = "code";
+		state.out.push(char);
+	} else {
+		state.out.push(" ");
+	}
+	state.index += 1;
+}
+
+function stepBlockComment(state: BlankState, text: string): void {
+	const char = text.charAt(state.index);
+	const next = text.charAt(state.index + 1);
+	if (char === "*" && next === "/") {
+		state.state = "code";
+		state.out.push(" ", " ");
+		state.index += 2;
+		return;
+	}
+	pushNewlineOrSpace(state, char);
+}
+
+function stepString(state: BlankState, text: string): void {
+	const char = text.charAt(state.index);
+	const next = text.charAt(state.index + 1);
+	if (char === "\\") {
+		state.out.push(" ", " ");
+		state.index += 2;
+		return;
+	}
+	if (state.quote === "`" && char === "$" && next === "{") {
+		state.templateTops.push(state.depth);
+		state.depth += 1;
+		state.state = "code";
+		state.out.push(" ", " ");
+		state.index += 2;
+		return;
+	}
+	if (char === state.quote) {
+		state.state = "code";
+		state.out.push(" ");
+		state.index += 1;
+		return;
+	}
+	pushNewlineOrSpace(state, char);
+}
+
+function stepCodeBrace(state: BlankState, char: string): boolean {
+	if (char === "{") {
+		state.depth += 1;
+		state.out.push(char);
+		state.index += 1;
+		return true;
+	}
+	if (char === "}") {
+		state.depth -= 1;
+		if (state.depth < 0) {
+			state.depth = 0;
+		}
+		const top = state.templateTops[state.templateTops.length - 1];
+		if (top !== undefined && state.depth === top) {
+			state.templateTops.pop();
+			state.state = "string";
+			state.quote = "`";
+		}
+		state.out.push(char);
+		state.index += 1;
+		return true;
+	}
+	return false;
+}
+
+function stepCode(state: BlankState, text: string): void {
+	const char = text.charAt(state.index);
+	const next = text.charAt(state.index + 1);
+	if (char === "/" && next === "/") {
+		state.state = "line";
+		state.out.push(" ", " ");
+		state.index += 2;
+		return;
+	}
+	if (char === "/" && next === "*") {
+		state.state = "block";
+		state.out.push(" ", " ");
+		state.index += 2;
+		return;
+	}
+	if (char === "'" || char === '"' || char === "`") {
+		state.state = "string";
+		state.quote = char;
+		state.out.push(" ");
+		state.index += 1;
+		return;
+	}
+	if (!stepCodeBrace(state, char)) {
+		state.out.push(char);
+		state.index += 1;
+	}
+}
+
+// SPEC §4.11.3: the lexer ignores `require` inside strings and comments
+// (EC-7); blanking them first keeps every later regex honest.
+export function blankCode(text: string): string {
+	const state: BlankState = {
+		out: [],
+		index: 0,
+		state: "code",
+		quote: "",
+		depth: 0,
+		templateTops: [],
+	};
+	while (state.index < text.length) {
+		if (state.state === "code") {
+			stepCode(state, text);
+		} else if (state.state === "line") {
+			stepLineComment(state, text.charAt(state.index));
+		} else if (state.state === "block") {
+			stepBlockComment(state, text);
+		} else {
+			stepString(state, text);
+		}
+	}
+	return state.out.join("");
+}

package/dist/builtin-packs/typescript/measures-exports.ts

@@ -0,0 +1,173 @@
+// SPEC §6.1 measures: dead code as an exported name in a non-entry file
+// with no importer.
+import { extractImports } from "./extract.ts";
+import { matchWordAt, skipTrivia } from "./extract-words.ts";
+import { blankCode } from "./lex.ts";
+import { isBareSpecifier, resolveRelativeSpecifier } from "./resolve.ts";
+
+function namesFromBinding(fragment: string): Array<string> {
+	const head = fragment.split("=", 1)[0] ?? "";
+	const names: Array<string> = [];
+	for (const match of head.matchAll(/[A-Za-z_$][\w$]*/g)) {
+		const name = match[0];
+		if (name !== "as" && name !== "type") {
+			names.push(name);
+		}
+	}
+	return names;
+}
+
+function namesFromList(fragment: string): Array<string> {
+	const names: Array<string> = [];
+	for (const part of fragment.split(",")) {
+		const trimmed = part.trim();
+		if (trimmed === "") {
+			continue;
+		}
+		const asIndex = trimmed.search(/\bas\b/);
+		const alias = asIndex >= 0 ? trimmed.slice(asIndex + 2).trim() : trimmed;
+		const identifier = alias.match(/^[A-Za-z_$][\w$]*/);
+		if (identifier !== null) {
+			names.push(identifier[0]);
+		}
+	}
+	return names;
+}
+
+// Locally defined names only; `export … from` re-exports belong to their
+// origin file, and `export *` names nothing here.
+export function findExportedNames(text: string): Array<string> {
+	const code = blankCode(text);
+	const names: Array<string> = [];
+	const cursor = { index: 0 };
+	while (cursor.index < code.length) {
+		if (!matchWordAt(code, cursor.index, "export")) {
+			cursor.index += 1;
+			continue;
+		}
+		let next = skipTrivia(code, cursor.index + 6);
+		if (matchWordAt(code, next, "type")) {
+			next = skipTrivia(code, next + 4);
+		}
+		if (matchWordAt(code, next, "default")) {
+			names.push("default");
+			cursor.index = next + 7;
+			continue;
+		}
+		if (code.charAt(next) === "{") {
+			const close = code.indexOf("}", next);
+			if (close < 0) {
+				break;
+			}
+			const fromWord = code.slice(close, close + 8);
+			if (matchWordAt(code, close + 1, "from") || fromWord.includes("from")) {
+				cursor.index = close + 1;
+				continue;
+			}
+			for (const name of namesFromList(code.slice(next + 1, close))) {
+				names.push(name);
+			}
+			cursor.index = close + 1;
+			continue;
+		}
+		if (code.charAt(next) === "*") {
+			cursor.index = next + 1;
+			continue;
+		}
+		const rest = code.slice(next, next + 40);
+		const declared =
+			/^(?:declare\s+)?(?:async\s+)?(?:abstract\s+)?(?:function\s*\*?\s*|class\s+|interface\s+|type\s+|enum\s+|const\s+|let\s+|var\s+)([A-Za-z_$][\w$]*)/.exec(
+				rest,
+			);
+		if (declared !== null) {
+			const name = declared[1] ?? "";
+			if (name !== "") {
+				names.push(name);
+			}
+			cursor.index = next + declared[0].length;
+			continue;
+		}
+		const binding = /^(?:declare\s+)?(?:const|let|var)\s*([{[].*?)[;=]/.exec(
+			rest,
+		);
+		if (binding !== null) {
+			for (const name of namesFromBinding(binding[1] ?? "")) {
+				names.push(name);
+			}
+			cursor.index = next + binding[0].length;
+			continue;
+		}
+		cursor.index = next + 1;
+	}
+	return [...new Set(names)].sort();
+}
+
+const CANDIDATE_EXTENSIONS: ReadonlyArray<string> = [
+	"",
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+];
+
+function resolveToFile(
+	spec: string,
+	from: string,
+	known: ReadonlySet<string>,
+): string | undefined {
+	if (isBareSpecifier(spec)) {
+		return undefined;
+	}
+	const base = resolveRelativeSpecifier(from, spec);
+	for (const extension of CANDIDATE_EXTENSIONS) {
+		const candidate = `${base}${extension}`;
+		if (known.has(candidate)) {
+			return candidate;
+		}
+	}
+	for (const extension of CANDIDATE_EXTENSIONS.slice(1)) {
+		const candidate = `${base}/index${extension}`;
+		if (known.has(candidate)) {
+			return candidate;
+		}
+	}
+	return undefined;
+}
+
+// A namespace or default import uses the module opaquely, so it counts as an
+// importer of every name; named imports will refine this when the extractor
+// carries binding names.
+export function findDeadExports(
+	files: Readonly<Record<string, string>>,
+	isEntry: (path: string) => boolean,
+): Array<{ readonly path: string; readonly name: string }> {
+	const known = new Set(Object.keys(files));
+	const imported = new Set<string>();
+	for (const from of known) {
+		const content = files[from] ?? "";
+		for (const ref of extractImports(from, content)) {
+			const target = resolveToFile(ref.to, from, known);
+			if (target !== undefined) {
+				imported.add(target);
+			}
+		}
+	}
+	const dead: Array<{ readonly path: string; readonly name: string }> = [];
+	for (const path of [...known].sort()) {
+		if (isEntry(path)) {
+			continue;
+		}
+		if (imported.has(path)) {
+			continue;
+		}
+		const content = files[path] ?? "";
+		for (const name of findExportedNames(content)) {
+			dead.push({ path, name });
+		}
+	}
+	return dead;
+}

package/dist/builtin-packs/typescript/measures-functions.ts

@@ -0,0 +1,138 @@
+// SPEC §6.1 measures: function size by brace matching from `function`,
+// method and arrow-body starts; cyclomatic as 1 plus the branch tokens.
+import { skipTrivia } from "./extract-words.ts";
+import { blankCode, lineAtIndex, lineStartsFor } from "./lex.ts";
+
+export interface FunctionSpan {
+	readonly line: number;
+	readonly lines: number;
+}
+
+// SPEC §6.1: 1 + `if`, `for`, `while`, `case`, `catch`, `&&`, `||`, `??`
+// and the ternary `?`. The ternary excludes `?.`, `??` and `?:` (optional
+// members), so an optional parameter never counts as a branch.
+// Patterns live at module scope so the branch words they name never count
+// as branches of the function that applies them.
+const WORDS_RE = /\b(if|for|while|case|catch)\b/g;
+const ANDS_RE = /&&/g;
+const ORS_RE = /\|\|/g;
+const NULLISH_RE = /\?\?/g;
+const TERNARY_RE = /\?(?![?.:])/g;
+
+function countWith(code: string, pattern: RegExp): Array<string> {
+	return code.match(pattern) ?? [];
+}
+
+export function measureCyclomatic(text: string): number {
+	const code = blankCode(text);
+	const words = countWith(code, WORDS_RE).length;
+	const ands = countWith(code, ANDS_RE).length;
+	const ors = countWith(code, ORS_RE).length;
+	const nullish = countWith(code, NULLISH_RE).length;
+	const withoutNullish = code.split("??").join("  ");
+	const ternary = countWith(withoutNullish, TERNARY_RE).length;
+	return 1 + words + ands + ors + nullish + ternary;
+}
+
+function matchBrace(blanked: string, open: number): number {
+	let depth = 0;
+	for (let index = open; index < blanked.length; index += 1) {
+		const char = blanked.charAt(index);
+		if (char === "{") {
+			depth += 1;
+		} else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				return index;
+			}
+		}
+	}
+	return -1;
+}
+
+function nextBrace(blanked: string, index: number): number {
+	const open = blanked.indexOf("{", index);
+	return open;
+}
+
+// Method shorthand on one line: `name(...) {`, with async/static/get/set.
+const METHOD_RE =
+	/^[ \t]*(?:async[ \t]+)?(?:static[ \t]+)?(?:get[ \t]+|set[ \t]+)?[A-Za-z_$][\w$]*[ \t]*\([^();{}]*\)[ \t]*\{/gm;
+
+function findStarts(blanked: string): Array<number> {
+	const starts: Array<number> = [];
+	const seen = new Set<number>();
+	const push = (index: number): void => {
+		if (!seen.has(index)) {
+			seen.add(index);
+			starts.push(index);
+		}
+	};
+	for (const match of blanked.matchAll(/\bfunction\b|=>/g)) {
+		const at = match.index ?? -1;
+		if (at >= 0) {
+			push(at);
+		}
+	}
+	for (const match of blanked.matchAll(METHOD_RE)) {
+		const at = match.index ?? -1;
+		if (at >= 0) {
+			push(at + match[0].lastIndexOf("{"));
+		}
+	}
+	return starts.sort((a, b) => a - b);
+}
+
+function spanFromBrace(
+	starts: ReadonlyArray<number>,
+	blanked: string,
+	from: number,
+): FunctionSpan | undefined {
+	const open = nextBrace(blanked, from);
+	if (open < 0) {
+		return undefined;
+	}
+	const close = matchBrace(blanked, open);
+	if (close < 0) {
+		return undefined;
+	}
+	const line = lineAtIndex(starts, from);
+	return { line, lines: lineAtIndex(starts, close) - line + 1 };
+}
+
+function spanFromArrow(
+	starts: ReadonlyArray<number>,
+	blanked: string,
+	text: string,
+	arrow: number,
+): FunctionSpan | undefined {
+	const body = skipTrivia(text, arrow + 2);
+	if (text.charAt(body) === "{") {
+		return spanFromBrace(starts, blanked, arrow);
+	}
+	const line = lineAtIndex(starts, arrow);
+	return { line, lines: 1 };
+}
+
+// Every span reports its definition line and length; nested functions report
+// separately, so each body is judged on its own.
+export function measureFunctionSizes(text: string): Array<FunctionSpan> {
+	const blanked = blankCode(text);
+	const starts = lineStartsFor(text);
+	const spans: Array<FunctionSpan> = [];
+	for (const from of findStarts(blanked)) {
+		const word = blanked.slice(from, from + 8);
+		let span: FunctionSpan | undefined;
+		if (word.startsWith("=>")) {
+			span = spanFromArrow(starts, blanked, text, from);
+		} else if (word.startsWith("function")) {
+			span = spanFromBrace(starts, blanked, from);
+		} else {
+			span = spanFromBrace(starts, blanked, from);
+		}
+		if (span !== undefined && span.lines > 0) {
+			spans.push(span);
+		}
+	}
+	return spans.sort((a, b) => a.line - b.line);
+}

package/dist/builtin-packs/typescript/measures.ts

@@ -0,0 +1,10 @@
+// SPEC §6.1 measures: re-export surface split by responsibility —
+// function-size and cyclomatic spans in measures-functions.ts, exported-name
+// and dead-export scans in measures-exports.ts.
+
+export { findDeadExports, findExportedNames } from "./measures-exports.ts";
+export type { FunctionSpan } from "./measures-functions.ts";
+export {
+	measureCyclomatic,
+	measureFunctionSizes,
+} from "./measures-functions.ts";

package/dist/builtin-packs/typescript/naming.ts

@@ -0,0 +1,47 @@
+// SPEC §6.1 file naming: `kebab-case` for `.ts`, `.tsx`, `.js`, `.mjs`,
+// `.cjs`; tests are `*.test.<ext>`; framework-reserved names (`[id].tsx`,
+// `+page.svelte`, `_app.tsx`) stay allowed. Consumed by `core/file-naming`.
+function baseName(path: string): string {
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return slash < 0 ? path : path.slice(slash + 1);
+}
+
+function isKebabStem(stem: string): boolean {
+	return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(stem);
+}
+
+// Test files carry `.test.` before the extension: `sample.test.ts`.
+export function isTestFileName(path: string): boolean {
+	const name = baseName(path).toLowerCase();
+	return name.includes(".test.");
+}
+
+// Framework-reserved names escape kebab-case: bracket routes, `+` pages and
+// `_` layouts are the framework's contract, not the author's choice.
+export function isFrameworkReservedName(path: string): boolean {
+	const name = baseName(path);
+	return name.startsWith("[") || name.startsWith("+") || name.startsWith("_");
+}
+
+export function checkTypeScriptFileName(path: string): {
+	readonly ok: boolean;
+	readonly reason: string;
+} {
+	const name = baseName(path);
+	if (isFrameworkReservedName(path)) {
+		return { ok: true, reason: "" };
+	}
+	if (isTestFileName(path)) {
+		const stem = name.slice(0, name.toLowerCase().indexOf(".test."));
+		if (isKebabStem(stem)) {
+			return { ok: true, reason: "" };
+		}
+		return { ok: false, reason: `test file stem "${stem}" is not kebab-case` };
+	}
+	const dot = name.lastIndexOf(".");
+	const stem = dot < 0 ? name : name.slice(0, dot);
+	if (isKebabStem(stem)) {
+		return { ok: true, reason: "" };
+	}
+	return { ok: false, reason: `file stem "${stem}" is not kebab-case` };
+}