aislop 0.8.2 → 0.9.0

package/dist/mcp.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { n as runSubprocess, t as isToolInstalled } from "./subprocess-CCnnN_oQ.js";
 import { createRequire, isBuiltin } from "node:module";
+import { performance } from "node:perf_hooks";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import path from "node:path";
@@ -9,11 +10,11 @@ import { z } from "zod";
 import fs from "node:fs";
 import YAML from "yaml";
 import { z as z$1 } from "zod/v4";
-import { performance } from "node:perf_hooks";
 import micromatch from "micromatch";
 import { fileURLToPath } from "node:url";
 import os from "node:os";
 import "typescript";
+import { randomUUID } from "node:crypto";
 
 //#region src/config/defaults.ts
 const DEFAULT_CONFIG = {
@@ -1253,6 +1254,27 @@ const collectJsDeps = (rootDir, jsDeps) => {
 	collectNestedManifests(rootDir, jsDeps);
 	return true;
 };
+const TS_CONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+const buildAliasMatcher = (key) => {
+	const starIdx = key.indexOf("*");
+	if (starIdx === -1) return (spec) => spec === key;
+	const before = key.slice(0, starIdx);
+	const after = key.slice(starIdx + 1);
+	return (spec) => spec.length >= before.length + after.length && spec.startsWith(before) && spec.endsWith(after);
+};
+const collectAliasMatchersFromConfig = (configPath, matchers) => {
+	const opts = readJson(configPath)?.compilerOptions;
+	if (!opts || typeof opts !== "object") return;
+	const paths = opts.paths;
+	if (!paths || typeof paths !== "object") return;
+	for (const key of Object.keys(paths)) matchers.push(buildAliasMatcher(key));
+};
+const collectTsPathAliases = (rootDir) => {
+	const matchers = [];
+	const dirs = [rootDir, ...expandWorkspaceDirs(rootDir, readWorkspaceGlobs(rootDir, readJson(path.join(rootDir, "package.json"))))];
+	for (const dir of dirs) for (const fname of TS_CONFIG_FILES) collectAliasMatchersFromConfig(path.join(dir, fname), matchers);
+	return matchers;
+};
 const addPyDep = (pyDeps, name) => {
 	const normalized = name.toLowerCase().replace(/_/g, "-");
 	pyDeps.add(normalized);
@@ -1410,10 +1432,11 @@ const extractPyImports = (content) => {
 	}
 	return results;
 };
-const checkJsImport = (spec, manifest) => {
+const checkJsImport = (spec, manifest, tsAliasMatchers) => {
 	if (isJsRelativeOrAbsolute(spec)) return null;
 	if (isJsBuiltin(spec)) return null;
 	if (isJsVirtualModule(spec)) return null;
+	if (tsAliasMatchers.some((m) => m(spec))) return null;
 	const pkg = packageNameFromImport(spec);
 	if (manifest.jsDeps.has(pkg)) return null;
 	if (pkg.startsWith("@types/")) {
@@ -1434,6 +1457,7 @@ const checkPyImport = (spec, manifest) => {
 const detectHallucinatedImports = async (context) => {
 	const manifest = loadManifest(context.rootDirectory);
 	if (!manifest.hasJsManifest && !manifest.hasPyManifest) return [];
+	const tsAliasMatchers = manifest.hasJsManifest ? collectTsPathAliases(context.rootDirectory) : [];
 	const diagnostics = [];
 	const files = getSourceFiles(context);
 	for (const filePath of files) {
@@ -1453,7 +1477,7 @@ const detectHallucinatedImports = async (context) => {
 		const relPath = path.relative(context.rootDirectory, filePath);
 		const imports = isJs ? extractJsImports(content) : extractPyImports(content);
 		for (const { spec, line } of imports) {
-			const hallucinated = isJs ? checkJsImport(spec, manifest) : checkPyImport(spec, manifest);
+			const hallucinated = isJs ? checkJsImport(spec, manifest, tsAliasMatchers) : checkPyImport(spec, manifest);
 			if (!hallucinated) continue;
 			const manifestLabel = isJs ? "package.json" : "requirements.txt / pyproject.toml / Pipfile";
 			diagnostics.push({
@@ -5071,7 +5095,225 @@ const handleAislopBaseline = (input) => {
 
 //#endregion
 //#region src/version.ts
-const APP_VERSION = "0.8.2";
+const APP_VERSION = "0.9.0";
+
+//#endregion
+//#region src/telemetry/env.ts
+const detectPackageManager = (env = process.env) => {
+	const execPath = env.npm_execpath ?? "";
+	if (execPath.includes("npx")) return "npx";
+	const userAgent = env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("pnpm/")) return "pnpm";
+	if (userAgent.startsWith("yarn/")) return "yarn";
+	if (userAgent.startsWith("bun/")) return "bun";
+	if (userAgent.startsWith("npm/")) return "npm";
+	if (execPath.includes("pnpm")) return "pnpm";
+	if (execPath.includes("yarn")) return "yarn";
+	if (execPath.includes("bun")) return "bun";
+	if (execPath.includes("npm")) return "npm";
+	return "unknown";
+};
+const CI_ENV_KEYS = [
+	"CI",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"CIRCLECI",
+	"TRAVIS",
+	"BUILDKITE",
+	"DRONE",
+	"TEAMCITY_VERSION",
+	"TF_BUILD"
+];
+const isCiEnv = (env = process.env) => CI_ENV_KEYS.some((k) => {
+	const v = env[k];
+	return v === "true" || v === "1" || v != null && v.length > 0 && k !== "CI";
+}) || env.CI === "true" || env.CI === "1";
+
+//#endregion
+//#region src/telemetry/identity.ts
+const FILE_BASENAME = "install_id";
+const resolveInstallIdPath = (homedir = os.homedir(), env = process.env) => {
+	if (process.platform === "linux" && env.XDG_STATE_HOME) return path.join(env.XDG_STATE_HOME, "aislop", FILE_BASENAME);
+	return path.join(homedir, ".aislop", FILE_BASENAME);
+};
+const ensureInstallId = (idPath = resolveInstallIdPath()) => {
+	if (fs.existsSync(idPath)) {
+		const existing = fs.readFileSync(idPath, "utf-8").trim();
+		if (existing.length > 0) return {
+			installId: existing,
+			created: false
+		};
+	}
+	const dir = path.dirname(idPath);
+	fs.mkdirSync(dir, { recursive: true });
+	const installId = randomUUID();
+	const tmpPath = `${idPath}.${process.pid}.tmp`;
+	fs.writeFileSync(tmpPath, `${installId}\n`, { mode: 384 });
+	try {
+		fs.renameSync(tmpPath, idPath);
+		return {
+			installId,
+			created: true
+		};
+	} catch {
+		fs.rmSync(tmpPath, { force: true });
+		return {
+			installId: fs.readFileSync(idPath, "utf-8").trim(),
+			created: false
+		};
+	}
+};
+
+//#endregion
+//#region src/telemetry/redaction.ts
+const SAFE_PROPERTY_NAMES = new Set([
+	"aislop_version",
+	"node_version",
+	"os",
+	"arch",
+	"schema_version",
+	"anonymous_install_id",
+	"package_manager",
+	"is_ci",
+	"command",
+	"language_summary",
+	"lang_typescript",
+	"lang_javascript",
+	"lang_python",
+	"lang_java",
+	"file_count_bucket",
+	"exit_code",
+	"duration_ms",
+	"error_kind",
+	"score",
+	"score_bucket",
+	"finding_count",
+	"error_count",
+	"warning_count",
+	"fixable_count",
+	"fix_steps",
+	"fix_resolved",
+	"fix_score_delta",
+	"engine_format_issues",
+	"engine_format_ms",
+	"engine_lint_issues",
+	"engine_lint_ms",
+	"engine_code_quality_issues",
+	"engine_code_quality_ms",
+	"engine_ai_slop_issues",
+	"engine_ai_slop_ms",
+	"engine_architecture_issues",
+	"engine_architecture_ms",
+	"engine_security_issues",
+	"engine_security_ms",
+	"tool",
+	"ok",
+	"agent",
+	"score_delta"
+]);
+const redactProperties = (props) => {
+	const clean = {};
+	const dropped = [];
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0) continue;
+		if (SAFE_PROPERTY_NAMES.has(key)) clean[key] = value;
+		else dropped.push(key);
+	}
+	return {
+		clean,
+		dropped
+	};
+};
+
+//#endregion
+//#region src/telemetry/client.ts
+const POSTHOG_HOST = "https://eu.i.posthog.com";
+const POSTHOG_KEY = "phc_eY2cOMFva9q24GrWeOuvuVIOhCIdjOALxeAR3ItrqbJ";
+const SCHEMA_VERSION = "v2";
+const REQUEST_TIMEOUT_MS = 3e3;
+const isTelemetryDisabled = (config) => {
+	const env = process.env;
+	if (env.AISLOP_NO_TELEMETRY === "1" || env.DO_NOT_TRACK === "1") return true;
+	if (config?.enabled === false) return true;
+	if (config?.enabled === true) return false;
+	if (env.CI === "true" || env.CI === "1") return true;
+	return false;
+};
+const isDebug = () => process.env.AISLOP_TELEMETRY_DEBUG === "1";
+const pendingRequests = /* @__PURE__ */ new Set();
+let cachedInstallId = null;
+let installCreated = false;
+const baseProperties = (installId) => ({
+	aislop_version: APP_VERSION,
+	node_version: process.version,
+	os: os.platform(),
+	arch: os.arch(),
+	schema_version: SCHEMA_VERSION,
+	anonymous_install_id: installId,
+	package_manager: detectPackageManager(),
+	is_ci: isCiEnv()
+});
+const track = (input) => {
+	if (isTelemetryDisabled(input.config)) return { installCreated: false };
+	if (cachedInstallId == null) {
+		const ensured = ensureInstallId(resolveInstallIdPath());
+		cachedInstallId = ensured.installId;
+		installCreated = ensured.created;
+	}
+	const { clean, dropped } = redactProperties({
+		...baseProperties(cachedInstallId),
+		...input.properties
+	});
+	if (isDebug()) {
+		const compact = JSON.stringify({
+			event: input.event,
+			properties: clean
+		});
+		process.stderr.write(`[telemetry] ${compact}\n`);
+		if (dropped.length > 0) for (const key of dropped) process.stderr.write(`[telemetry] dropped non-allowlisted property: ${key}\n`);
+	}
+	if (process.env.AISLOP_TELEMETRY_DRY_RUN === "1") return { installCreated };
+	const payload = {
+		api_key: POSTHOG_KEY,
+		event: input.event,
+		distinct_id: cachedInstallId,
+		properties: clean,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const request = fetch(`${POSTHOG_HOST}/capture/`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload),
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	}).then(() => {}).catch(() => {}).finally(() => {
+		pendingRequests.delete(request);
+	});
+	pendingRequests.add(request);
+	return { installCreated };
+};
+const flushTelemetry = async () => {
+	if (pendingRequests.size === 0) return;
+	await Promise.all(pendingRequests);
+};
+
+//#endregion
+//#region src/telemetry/events.ts
+const buildMcpToolCalledProps = (input) => {
+	const props = {
+		tool: input.tool,
+		duration_ms: Math.round(input.durationMs),
+		ok: input.ok
+	};
+	if (input.errorKind) props.error_kind = input.errorKind;
+	return props;
+};
+const errorKindFromException = (error) => {
+	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	if (message.includes("timeout") || message.includes("timed out")) return "timeout";
+	if (message.includes("invalid config") || message.includes("config_invalid")) return "config_invalid";
+	if (message.includes("engine") && message.includes("crash")) return "engine_crash";
+	return "unknown";
+};
 
 //#endregion
 //#region src/mcp.ts
@@ -5086,10 +5328,29 @@ const err = (message) => ({
 	}],
 	isError: true
 });
-const tryHandle = async (fn) => {
+const instrument = async (tool, fn) => {
+	const startedAt = performance.now();
 	try {
-		return ok(await fn());
+		const value = await fn();
+		track({
+			event: "mcp_tool_called",
+			properties: buildMcpToolCalledProps({
+				tool,
+				durationMs: performance.now() - startedAt,
+				ok: true
+			})
+		});
+		return ok(value);
 	} catch (e) {
+		track({
+			event: "mcp_tool_called",
+			properties: buildMcpToolCalledProps({
+				tool,
+				durationMs: performance.now() - startedAt,
+				ok: false,
+				errorKind: errorKindFromException(e)
+			})
+		});
 		return err(e instanceof Error ? e.message : String(e));
 	}
 };
@@ -5101,25 +5362,27 @@ const buildServer = () => {
 	server.registerTool(aislopScanTool.name, {
 		description: aislopScanTool.description,
 		inputSchema: aislopScanInputSchema.shape
-	}, (input) => tryHandle(() => handleAislopScan(input)));
+	}, (input) => instrument("aislop_scan", () => handleAislopScan(input)));
 	server.registerTool(aislopFixTool.name, {
 		description: aislopFixTool.description,
 		inputSchema: aislopFixInputSchema.shape
-	}, (input) => tryHandle(() => handleAislopFix(input)));
+	}, (input) => instrument("aislop_fix", () => handleAislopFix(input)));
 	server.registerTool(aislopWhyTool.name, {
 		description: aislopWhyTool.description,
 		inputSchema: aislopWhyInputSchema.shape
-	}, (input) => tryHandle(() => handleAislopWhy(input)));
+	}, (input) => instrument("aislop_why", () => handleAislopWhy(input)));
 	server.registerTool(aislopBaselineTool.name, {
 		description: aislopBaselineTool.description,
 		inputSchema: aislopBaselineInputSchema.shape
-	}, (input) => tryHandle(() => handleAislopBaseline(input)));
+	}, (input) => instrument("aislop_baseline", () => handleAislopBaseline(input)));
 	return server;
 };
 const main = async () => {
 	const server = buildServer();
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
+	track({ event: "mcp_server_started" });
+	await flushTelemetry();
 };
 main().catch((e) => {
 	process.stderr.write(`aislop-mcp failed to start: ${e instanceof Error ? e.message : String(e)}\n`);

package/dist/{typecheck-B1MXNAy-.js → typecheck-wVSohmOX.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as runSubprocess } from "./cli.js";
+import { n as runSubprocess } from "./cli.js";
 import fs from "node:fs";
 import path from "node:path";
 

package/dist/{version-G3ekYjY1.js → version-D_rqBdyj.js}

@@ -29,7 +29,7 @@ const getEngineLabel = (engine) => ENGINE_INFO[engine].label;
 
 //#endregion
 //#region src/version.ts
-const APP_VERSION = "0.8.2";
+const APP_VERSION = "0.9.0";
 
 //#endregion
 export { ENGINE_INFO as n, getEngineLabel as r, APP_VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aislop",
-	"version": "0.8.2",
+	"version": "0.9.0",
 	"description": "The engineering standards layer and quality gate for AI-written code. Define your standard once. Every agent — Claude Code, Cursor, Codex — is held to it automatically, on every edit and every PR. Catches the slop they leave behind, enforces the rules your team sets. 8+ languages. Deterministic.",
 	"type": "module",
 	"bin": {