codictator 0.0.0 → 0.1.2

package/dist/builtin-packs/typescript/extract-clauses.ts

@@ -0,0 +1,153 @@
+// SPEC §4.11.3 + §6.1: clause parsers for the TypeScript import extractor.
+// Covers ES `import`/`export … from`, dynamic `import()`, `require()` and
+// `import x = require()`; type imports stay edges (§4.11 EC-4). Non-literal
+// dynamic targets report `dynamic:expr` (§4.11 EC-5).
+import { readStringLiteral, skipAtom, skipQuoted } from "./extract-literals.ts";
+import { isWordChar, matchWordAt, skipTrivia } from "./extract-words.ts";
+
+// The `from "spec"` tail of a static import or re-export; the search stays
+// at brace depth zero so an imported name like `{ from }` never matches.
+export function findFromSpecifier(
+	text: string,
+	index: number,
+): { readonly spec: string; readonly next: number } | undefined {
+	let cursor = index;
+	let depth = 0;
+	while (cursor < text.length) {
+		const skipped = skipTrivia(text, cursor);
+		cursor = skipped === cursor ? skipAtom(text, cursor) : skipped;
+		if (cursor >= text.length) {
+			return undefined;
+		}
+		const char = text.charAt(cursor);
+		if (char === "{" || char === "(" || char === "[") {
+			depth += 1;
+			cursor += 1;
+			continue;
+		}
+		if (char === "}" || char === ")" || char === "]") {
+			if (depth === 0) {
+				return undefined;
+			}
+			depth -= 1;
+			cursor += 1;
+			continue;
+		}
+		if (char === ";" && depth === 0) {
+			return undefined;
+		}
+		if (depth === 0 && matchWordAt(text, cursor, "from")) {
+			const after = skipTrivia(text, cursor + 4);
+			const literal = readStringLiteral(text, after);
+			if (literal === undefined) {
+				return undefined;
+			}
+			return { spec: literal.value, next: literal.next };
+		}
+		if (char === "'" || char === '"' || char === "`") {
+			cursor = skipQuoted(text, cursor, char);
+			continue;
+		}
+		cursor += 1;
+	}
+	return undefined;
+}
+
+function readIdentifier(text: string, index: number): number {
+	let cursor = index;
+	while (cursor < text.length && isWordChar(text.charAt(cursor))) {
+		cursor += 1;
+	}
+	return cursor;
+}
+
+function parseDynamicImport(
+	text: string,
+	open: number,
+): { readonly spec: string; readonly next: number } {
+	const arg = skipTrivia(text, open + 1);
+	const literal = readStringLiteral(text, arg);
+	if (literal !== undefined) {
+		const after = skipTrivia(text, literal.next);
+		return {
+			spec: literal.value,
+			next: text.charAt(after) === ")" ? after + 1 : literal.next,
+		};
+	}
+	return { spec: "dynamic:expr", next: open + 1 };
+}
+
+function parseImportEquals(
+	text: string,
+	index: number,
+): { readonly spec: string; readonly next: number } | undefined {
+	const nameEnd = readIdentifier(text, index);
+	if (nameEnd === index) {
+		return undefined;
+	}
+	const afterName = skipTrivia(text, nameEnd);
+	if (text.charAt(afterName) !== "=") {
+		return undefined;
+	}
+	const afterEquals = skipTrivia(text, afterName + 1);
+	if (!matchWordAt(text, afterEquals, "require")) {
+		return undefined;
+	}
+	const arg = skipTrivia(text, afterEquals + 7);
+	if (text.charAt(arg) !== "(") {
+		return undefined;
+	}
+	const literal = readStringLiteral(text, skipTrivia(text, arg + 1));
+	if (literal === undefined) {
+		return { spec: "dynamic:expr", next: arg + 1 };
+	}
+	const after = skipTrivia(text, literal.next);
+	return {
+		spec: literal.value,
+		next: text.charAt(after) === ")" ? after + 1 : literal.next,
+	};
+}
+
+export function parseImportAt(
+	text: string,
+	index: number,
+): { readonly spec: string; readonly next: number } | undefined {
+	let cursor = skipTrivia(text, index + 6);
+	if (text.charAt(cursor) === "(") {
+		return parseDynamicImport(text, cursor);
+	}
+	if (matchWordAt(text, cursor, "type")) {
+		cursor = skipTrivia(text, cursor + 4);
+	}
+	const literal = readStringLiteral(text, cursor);
+	if (literal !== undefined) {
+		return { spec: literal.value, next: literal.next };
+	}
+	const equals = parseImportEquals(text, cursor);
+	if (equals !== undefined) {
+		return equals;
+	}
+	return findFromSpecifier(text, cursor);
+}
+
+export function parseExportAt(
+	text: string,
+	index: number,
+): { readonly spec: string; readonly next: number } | undefined {
+	let cursor = skipTrivia(text, index + 6);
+	if (matchWordAt(text, cursor, "type")) {
+		cursor = skipTrivia(text, cursor + 4);
+	}
+	return findFromSpecifier(text, cursor);
+}
+
+export function parseRequireAt(
+	text: string,
+	index: number,
+): { readonly spec: string; readonly next: number } | undefined {
+	const open = skipTrivia(text, index + 7);
+	if (text.charAt(open) !== "(") {
+		return undefined;
+	}
+	return parseDynamicImport(text, open);
+}

package/dist/builtin-packs/typescript/extract-literals.ts

@@ -0,0 +1,111 @@
+// SPEC §4.11.3 + §6.1: quoted-region scanners for the TypeScript import
+// extractor. Strings and comments never yield edges (§4.11 EC-7), so these
+// skippers keep every later scan honest without the compiler API.
+
+// Skip a quoted region; template `${}` holes recurse through balanced code.
+function skipBalanced(text: string, index: number): number {
+	let cursor = index + 1;
+	let depth = 1;
+	while (cursor < text.length && depth > 0) {
+		const nested = skipAtom(text, cursor);
+		if (text.charAt(nested) === "{") {
+			depth += 1;
+		} else if (text.charAt(nested) === "}") {
+			depth -= 1;
+		}
+		cursor = nested + 1;
+	}
+	return cursor;
+}
+
+export function skipQuoted(text: string, index: number, quote: string): number {
+	let cursor = index + 1;
+	while (cursor < text.length) {
+		const char = text.charAt(cursor);
+		if (char === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (quote === "`" && char === "$" && text.charAt(cursor + 1) === "{") {
+			cursor = skipBalanced(text, cursor + 1);
+			continue;
+		}
+		if (char === quote) {
+			return cursor + 1;
+		}
+		cursor += 1;
+	}
+	return cursor;
+}
+
+function isQuoteChar(char: string): boolean {
+	return char === "'" || char === '"' || char === "`";
+}
+
+function skipLineToEnd(text: string, index: number): number {
+	let cursor = index;
+	while (cursor < text.length && text.charAt(cursor) !== "\n") {
+		cursor += 1;
+	}
+	return cursor;
+}
+
+function skipBlockToEnd(text: string, index: number): number {
+	let cursor = index + 2;
+	while (cursor < text.length) {
+		if (text.charAt(cursor) === "*" && text.charAt(cursor + 1) === "/") {
+			return cursor + 2;
+		}
+		cursor += 1;
+	}
+	return cursor;
+}
+
+export function skipAtom(text: string, index: number): number {
+	const char = text.charAt(index);
+	const next = text.charAt(index + 1);
+	if (char === "/" && next === "/") {
+		return skipLineToEnd(text, index);
+	}
+	if (char === "/" && next === "*") {
+		return skipBlockToEnd(text, index);
+	}
+	if (isQuoteChar(char)) {
+		return skipQuoted(text, index, char);
+	}
+	return index;
+}
+
+// Reads a literal specifier; a template holding `${}` is not a literal, so
+// the caller reports it unresolvable instead of inventing a target.
+export function readStringLiteral(
+	text: string,
+	index: number,
+): { readonly value: string; readonly next: number } | undefined {
+	const quote = text.charAt(index);
+	if (quote !== "'" && quote !== '"' && quote !== "`") {
+		return undefined;
+	}
+	let value = "";
+	let cursor = index + 1;
+	while (cursor < text.length) {
+		const char = text.charAt(cursor);
+		if (char === "\\") {
+			value += text.slice(cursor, cursor + 2);
+			cursor += 2;
+			continue;
+		}
+		if (quote === "`" && char === "$" && text.charAt(cursor + 1) === "{") {
+			return undefined;
+		}
+		if (char === quote) {
+			return { value, next: cursor + 1 };
+		}
+		if (char === "\n" && quote !== "`") {
+			return undefined;
+		}
+		value += char;
+		cursor += 1;
+	}
+	return undefined;
+}

package/dist/builtin-packs/typescript/extract-words.ts

@@ -0,0 +1,79 @@
+// SPEC §4.11.3 + §6.1: word-boundary and trivia primitives shared by the
+// TypeScript import extractor and its sibling supplies (measures, titles).
+
+export function isWordChar(char: string): boolean {
+	return (
+		(char >= "A" && char <= "Z") ||
+		(char >= "a" && char <= "z") ||
+		(char >= "0" && char <= "9") ||
+		char === "_" ||
+		char === "$"
+	);
+}
+
+// A keyword match needs boundaries on both sides, so `required` never reads
+// as `require` and `important` never reads as `import`.
+export function matchWordAt(
+	text: string,
+	index: number,
+	word: string,
+): boolean {
+	if (!text.startsWith(word, index)) {
+		return false;
+	}
+	const before = index === 0 ? "" : text.charAt(index - 1);
+	const after = text.charAt(index + word.length);
+	if (before !== "" && isWordChar(before)) {
+		return false;
+	}
+	if (after !== "" && isWordChar(after)) {
+		return false;
+	}
+	return true;
+}
+
+function isTriviaSpace(char: string): boolean {
+	return char === " " || char === "\t" || char === "\n" || char === "\r";
+}
+
+function skipLineEnd(text: string, cursor: number): number {
+	let end = cursor;
+	while (end < text.length && text.charAt(end) !== "\n") {
+		end += 1;
+	}
+	return end;
+}
+
+function skipBlockEnd(text: string, cursor: number): number {
+	let end = cursor + 2;
+	while (end < text.length) {
+		if (text.charAt(end) === "*" && text.charAt(end + 1) === "/") {
+			return end + 2;
+		}
+		end += 1;
+	}
+	return end;
+}
+
+// Whitespace and comments end wherever a string or code token starts.
+export function skipTrivia(text: string, index: number): number {
+	let cursor = index;
+	while (cursor < text.length) {
+		const char = text.charAt(cursor);
+		const next = text.charAt(cursor + 1);
+		if (isTriviaSpace(char)) {
+			cursor += 1;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			cursor = skipLineEnd(text, cursor);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			cursor = skipBlockEnd(text, cursor);
+			continue;
+		}
+		break;
+	}
+	return cursor;
+}

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

@@ -0,0 +1,77 @@
+// SPEC §4.11.3 + §6.1: the TypeScript/JavaScript import extractor. A lexer,
+// never the compiler API: the zero-deps rule for packages/codictator
+// forbids the TypeScript compiler at runtime. Word primitives live in
+// extract-words, quoted scanners in extract-literals and clause parsers in
+// extract-clauses; this entry owns the single scan pass only.
+import type { ImportExtractor, ImportRef } from "../../features/arch/index.ts";
+import {
+	parseExportAt,
+	parseImportAt,
+	parseRequireAt,
+} from "./extract-clauses.ts";
+import { skipAtom } from "./extract-literals.ts";
+import { matchWordAt } from "./extract-words.ts";
+import {
+	lineAtIndex,
+	lineStartsFor,
+	TYPESCRIPT_SOURCE_EXTENSIONS,
+	toPosixPath,
+} from "./lex.ts";
+
+// SPEC §4.11.3: lexes each source file in one pass; the scan order keeps
+// the output deterministic without a later sort.
+export function extractImports(
+	fromPath: string,
+	text: string,
+): Array<ImportRef> {
+	const from = toPosixPath(fromPath);
+	const starts = lineStartsFor(text);
+	const refs: Array<ImportRef> = [];
+	let index = 0;
+	while (index < text.length) {
+		const char = text.charAt(index);
+		const next = text.charAt(index + 1);
+		if (char === "/" && (next === "/" || next === "*")) {
+			index = skipAtom(text, index);
+			continue;
+		}
+		if (char === "'" || char === '"' || char === "`") {
+			index = skipAtom(text, index);
+			continue;
+		}
+		if (matchWordAt(text, index, "import")) {
+			const parsed = parseImportAt(text, index);
+			if (parsed !== undefined) {
+				refs.push({ from, to: parsed.spec, line: lineAtIndex(starts, index) });
+				index = parsed.next;
+				continue;
+			}
+		} else if (matchWordAt(text, index, "export")) {
+			const parsed = parseExportAt(text, index);
+			if (parsed !== undefined) {
+				refs.push({ from, to: parsed.spec, line: lineAtIndex(starts, index) });
+				index = parsed.next;
+				continue;
+			}
+		} else if (matchWordAt(text, index, "require")) {
+			const parsed = parseRequireAt(text, index);
+			if (parsed !== undefined) {
+				refs.push({ from, to: parsed.spec, line: lineAtIndex(starts, index) });
+				index = parsed.next;
+				continue;
+			}
+		}
+		index += 1;
+	}
+	return refs;
+}
+
+// SPEC §3.4: the per-language extractor the arch graph consumes.
+export function typescriptExtractor(): ImportExtractor {
+	return {
+		language: "typescript",
+		extensions: [...TYPESCRIPT_SOURCE_EXTENSIONS],
+		extract: (path: string, text: string): Array<ImportRef> =>
+			extractImports(path, text),
+	};
+}

package/dist/builtin-packs/typescript/fixtures/lint/passing/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/lint",
+	"section": "§6.1",
+	"expectation": "passing",
+	"trigger": "unused var binding failing the linter",
+	"expectRules": [],
+	"files": {
+		"sample.ts": "const used = 1;\nconsole.log(used);\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/lint/violating/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/lint",
+	"section": "§6.1",
+	"expectation": "violating",
+	"trigger": "unused var binding failing the linter",
+	"expectRules": ["ts/lint"],
+	"files": {
+		"sample.ts": "var unused = 1;\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/no-phantom-import/passing/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/no-phantom-import",
+	"section": "§6.1",
+	"expectation": "passing",
+	"trigger": "import of an undeclared package",
+	"expectRules": [],
+	"files": {
+		"sample.ts": "import \"node:fs\";\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/no-phantom-import/passing/host-provided/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/no-phantom-import",
+	"section": "§6.1",
+	"expectation": "passing",
+	"trigger": "host-provided vscode import inside the vscode package",
+	"expectRules": [],
+	"files": {
+		"packages/vscode/src/extension.cts": "import type { ExtensionContext } from \"vscode\";\n\nexport function activate(context: ExtensionContext): void {\n\tvoid context;\n}\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/no-phantom-import/violating/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/no-phantom-import",
+	"section": "§6.1",
+	"expectation": "violating",
+	"trigger": "import of an undeclared package",
+	"expectRules": ["ts/no-phantom-import"],
+	"files": {
+		"sample.ts": "import \"phantom-pkg\";\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/no-phantom-import/violating/host-provided/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/no-phantom-import",
+	"section": "§6.1",
+	"expectation": "violating",
+	"trigger": "host-provided vscode import outside the vscode package",
+	"expectRules": ["ts/no-phantom-import"],
+	"files": {
+		"packages/other/src/a.ts": "import type { ExtensionContext } from \"vscode\";\n\nexport function run(context: ExtensionContext): void {\n\tvoid context;\n}\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/security-patterns/passing/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/security-patterns",
+	"section": "§6.1",
+	"expectation": "passing",
+	"trigger": "eval on user input",
+	"expectRules": [],
+	"files": {
+		"sample.ts": "JSON.parse(userInput);\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/security-patterns/violating/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/security-patterns",
+	"section": "§6.1",
+	"expectation": "violating",
+	"trigger": "eval on user input",
+	"expectRules": ["ts/security-patterns"],
+	"files": {
+		"sample.ts": "eval(userInput);\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/typecheck/passing/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/typecheck",
+	"section": "§6.1",
+	"expectation": "passing",
+	"trigger": "type error assigning string to number",
+	"expectRules": [],
+	"files": {
+		"sample.ts": "const x: number = 1;\n"
+	}
+}

package/dist/builtin-packs/typescript/fixtures/typecheck/violating/basic/case.json

@@ -0,0 +1,10 @@
+{
+	"rule": "ts/typecheck",
+	"section": "§6.1",
+	"expectation": "violating",
+	"trigger": "type error assigning string to number",
+	"expectRules": ["ts/typecheck"],
+	"files": {
+		"sample.ts": "const x: number = \"oops\";\n"
+	}
+}

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

@@ -0,0 +1,85 @@
+// SPEC §4.4.2 and §6: the typescript built-in pack (language rules plus
+// ecosystem driver and extractors). Rule data lives in pack.json (SPEC
+// §7.3) and loads through the pack loader; this entry exposes the pack
+// identity with the §6.1 supplies the arch, testing and engine phases
+// consume (import extractor, measures, titles, patterns, naming, strict).
+import type { Pack } from "../../kernel/index.ts";
+
+export { extractImports, typescriptExtractor } from "./extract.ts";
+export { matchWordAt, skipTrivia } from "./extract-words.ts";
+export {
+	blankCode,
+	isTypeScriptFile,
+	lineAtIndex,
+	lineStartsFor,
+	TYPESCRIPT_SOURCE_EXTENSIONS,
+	toPosixPath,
+} from "./lex.ts";
+export type { FunctionSpan } from "./measures.ts";
+export {
+	findDeadExports,
+	findExportedNames,
+	measureCyclomatic,
+	measureFunctionSizes,
+} from "./measures.ts";
+export {
+	checkTypeScriptFileName,
+	isFrameworkReservedName,
+	isTestFileName,
+} from "./naming.ts";
+export type { TextMark } from "./patterns.ts";
+export {
+	ASSERTION_TOKENS,
+	countAssertions,
+	findSkipMarkers,
+	findSuppressions,
+	SKIP_MARKERS,
+	SUPPRESSION_TOKENS,
+} from "./patterns.ts";
+export {
+	collectDeclaredNames,
+	isBareSpecifier,
+	isBuiltinSpecifier,
+	isPhantomSpecifier,
+	isRelativeSpecifier,
+	isWorkspaceAllowed,
+	matchTsPaths,
+	normalizeImportPath,
+	resolveRelativeSpecifier,
+} from "./resolve.ts";
+export {
+	isJavaScriptOnlyRepo,
+	missingCheckJsFlags,
+	missingStrictFlags,
+	proposesTypescript,
+	resolveEffectiveOptions,
+	TYPESCRIPT_STRICT_FLAGS,
+} from "./strict.ts";
+export type { TestRunner, TestTitle } from "./titles.ts";
+export { extractTestTitles, testFilterArg } from "./titles.ts";
+
+// SPEC §6: typescript pack manifest with its driver and extractors. The
+// rules stay owned by pack.json and load via `loadBuiltinPack`; the pack
+// value here carries the identity the language-pack contract asserts while
+// steps 7.2–7.7 wire the enforcers that consume these supplies.
+export function typescriptPack(): Pack {
+	return {
+		manifest: {
+			id: "typescript",
+			version: "0.0.0",
+			description:
+				"Codictator TypeScript/JavaScript built-in pack (SPEC §6.1).",
+			rules: [],
+			enforcers: [],
+			drivers: [],
+			extractors: [],
+			measures: [],
+			capabilities: [],
+			assets: [],
+			maxWaiverDays: 90,
+		},
+		enforcers: [],
+		drivers: [],
+		assets: [],
+	};
+}