aislop 0.8.3 → 0.9.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as ENGINE_INFO, r as getEngineLabel, t as APP_VERSION } from "./version-BynHxO1X.js";
+import { n as ENGINE_INFO, r as getEngineLabel, t as APP_VERSION } from "./version-D_rqBdyj.js";
 import { n as runSubprocess, t as isToolInstalled } from "./subprocess-CQUJDGgn.js";
 import { r as runGenericLinter, t as fixRubyLint } from "./generic-BrcWMW7E.js";
 import { n as runExpoDoctor } from "./expo-doctor-Bz0LZhQ6.js";
@@ -15,6 +15,7 @@ import { fileURLToPath } from "node:url";
 import { performance } from "node:perf_hooks";
 import os from "node:os";
 import ts from "typescript";
+import { randomUUID } from "node:crypto";
 import { isCancel, multiselect, select, text } from "@clack/prompts";
 
 //#region src/config/defaults.ts
@@ -5874,60 +5875,348 @@ var LiveRail = class {
 };
 
 //#endregion
-//#region src/utils/telemetry.ts
-const POSTHOG_HOST = "https://eu.i.posthog.com";
-const POSTHOG_KEY = "phc_eY2cOMFva9q24GrWeOuvuVIOhCIdjOALxeAR3ItrqbJ";
-/**
-* Returns true if telemetry should be disabled.
-* Telemetry is opt-out: it runs unless explicitly disabled.
-*/
-const isTelemetryDisabled = (configEnabled) => {
-	if (process.env.AISLOP_NO_TELEMETRY === "1" || process.env.DO_NOT_TRACK === "1") return true;
-	if (process.env.CI === "true" || process.env.CI === "1") return true;
-	if (configEnabled === false) return true;
-	return false;
-};
-const getScoreBucket = (score) => {
+//#region src/telemetry/env.ts
+const detectPackageManager$1 = (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";
+const fileCountBucket = (count) => {
+	if (count < 10) return "0-10";
+	if (count < 50) return "10-50";
+	if (count < 100) return "50-100";
+	if (count < 500) return "100-500";
+	if (count < 1e3) return "500-1000";
+	return "1000+";
+};
+const scoreBucket = (score) => {
 	if (score >= 75) return "75-100";
 	if (score >= 50) return "50-75";
 	if (score >= 25) return "25-50";
 	return "0-25";
 };
-const getAnonymousId = () => {
-	const raw = `${os.hostname()}-${os.platform()}-${os.arch()}`;
-	let hash = 5381;
-	for (let i = 0; i < raw.length; i++) hash = hash * 33 ^ raw.charCodeAt(i);
-	return `aislop_${(hash >>> 0).toString(36)}`;
+
+//#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
+		};
+	}
 };
-/** Pending telemetry request — kept alive so Node doesn't exit before it completes. */
-let pendingRequest = null;
-const trackEvent = (event) => {
+
+//#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$1(),
+	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: `cli_${event.command}`,
-		distinct_id: getAnonymousId(),
-		properties: {
-			version: APP_VERSION,
-			node_version: process.version,
-			os: os.platform(),
-			arch: os.arch(),
-			languages: event.languages,
-			score_bucket: event.scoreBucket,
-			engine_issues: event.engineIssues,
-			engine_timings: event.engineTimings,
-			elapsed_ms: event.elapsedMs,
-			file_count: event.fileCount,
-			fix_steps: event.fixSteps,
-			fix_resolved: event.fixResolved
-		},
+		event: input.event,
+		distinct_id: cachedInstallId,
+		properties: clean,
 		timestamp: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	pendingRequest = fetch(`${POSTHOG_HOST}/capture/`, {
+	const request = fetch(`${POSTHOG_HOST}/capture/`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify(payload),
-		signal: AbortSignal.timeout(3e3)
-	}).then(() => {}).catch(() => {});
+		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/language.ts
+const ALL_LANGUAGES = [
+	"typescript",
+	"javascript",
+	"python",
+	"java"
+];
+const buildLanguageProperties = (detected) => {
+	const present = new Set(detected);
+	const summary = [...present].filter((l) => ALL_LANGUAGES.includes(l));
+	summary.sort();
+	return {
+		language_summary: summary.join(","),
+		lang_typescript: present.has("typescript"),
+		lang_javascript: present.has("javascript"),
+		lang_python: present.has("python"),
+		lang_java: present.has("java")
+	};
+};
+
+//#endregion
+//#region src/telemetry/events.ts
+const buildCommandStartedProps = (input) => {
+	const props = { command: input.command };
+	if (input.languages) Object.assign(props, buildLanguageProperties(input.languages));
+	if (typeof input.fileCount === "number") props.file_count_bucket = fileCountBucket(input.fileCount);
+	return props;
+};
+const ENGINE_KEY_MAP = {
+	format: "engine_format",
+	lint: "engine_lint",
+	"code-quality": "engine_code_quality",
+	"ai-slop": "engine_ai_slop",
+	architecture: "engine_architecture",
+	security: "engine_security"
+};
+const flattenEngineStats = (issues, timings) => {
+	const out = {};
+	for (const [engine, count] of Object.entries(issues)) {
+		const key = ENGINE_KEY_MAP[engine];
+		if (key != null && typeof count === "number") out[`${key}_issues`] = count;
+	}
+	for (const [engine, ms] of Object.entries(timings)) {
+		const key = ENGINE_KEY_MAP[engine];
+		if (key != null && typeof ms === "number") out[`${key}_ms`] = Math.round(ms);
+	}
+	return out;
+};
+const buildCommandCompletedProps = (input) => {
+	const props = {
+		...input.startProps,
+		exit_code: input.exitCode,
+		duration_ms: Math.round(input.durationMs)
+	};
+	if (input.errorKind) props.error_kind = input.errorKind;
+	if (typeof input.score === "number") {
+		props.score = input.score;
+		props.score_bucket = scoreBucket(input.score);
+	}
+	if (typeof input.findingCount === "number") props.finding_count = input.findingCount;
+	if (typeof input.errorCount === "number") props.error_count = input.errorCount;
+	if (typeof input.warningCount === "number") props.warning_count = input.warningCount;
+	if (typeof input.fixableCount === "number") props.fixable_count = input.fixableCount;
+	if (input.engineIssues && input.engineTimings) Object.assign(props, flattenEngineStats(input.engineIssues, input.engineTimings));
+	if (typeof input.fixSteps === "number") props.fix_steps = input.fixSteps;
+	if (typeof input.fixResolved === "number") props.fix_resolved = input.fixResolved;
+	if (typeof input.fixScoreDelta === "number") props.fix_score_delta = input.fixScoreDelta;
+	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/telemetry/lifecycle.ts
+const withCommandLifecycle = async (start, run) => {
+	const startProps = buildCommandStartedProps({
+		command: start.command,
+		languages: start.languages,
+		fileCount: start.fileCount
+	});
+	track({
+		event: "cli_command_started",
+		properties: startProps,
+		config: start.config
+	});
+	const startedAt = performance.now();
+	try {
+		const result = await run();
+		const durationMs = performance.now() - startedAt;
+		track({
+			event: "cli_command_completed",
+			properties: buildCommandCompletedProps({
+				startProps,
+				exitCode: result.exitCode,
+				durationMs,
+				score: result.score,
+				findingCount: result.findingCount,
+				errorCount: result.errorCount,
+				warningCount: result.warningCount,
+				fixableCount: result.fixableCount,
+				engineIssues: result.engineIssues,
+				engineTimings: result.engineTimings,
+				fixSteps: result.fixSteps,
+				fixResolved: result.fixResolved,
+				fixScoreDelta: result.fixScoreDelta
+			}),
+			config: start.config
+		});
+		await flushTelemetry();
+		return result;
+	} catch (error) {
+		track({
+			event: "cli_command_completed",
+			properties: buildCommandCompletedProps({
+				startProps,
+				exitCode: 1,
+				durationMs: performance.now() - startedAt,
+				errorKind: errorKindFromException(error)
+			}),
+			config: start.config
+		});
+		await flushTelemetry();
+		throw error;
+	}
 };
 
 //#endregion
@@ -6298,7 +6587,6 @@ const buildScanRender = (input) => {
 	}, deps)}`;
 };
 const scanCommand = async (directory, config, options) => {
-	const startTime = performance.now();
 	const resolvedDir = path.resolve(directory);
 	if (!fs.existsSync(resolvedDir)) {
 		const msg = `Path does not exist: ${resolvedDir}`;
@@ -6312,9 +6600,18 @@ const scanCommand = async (directory, config, options) => {
 		else log.error(msg);
 		return { exitCode: 1 };
 	}
+	const projectInfo = await discoverProject(resolvedDir);
+	return withCommandLifecycle({
+		command: options.command ?? "scan",
+		config: config.telemetry,
+		languages: projectInfo.languages,
+		fileCount: projectInfo.sourceFileCount
+	}, () => runScanBody(resolvedDir, config, options, projectInfo));
+};
+const runScanBody = async (resolvedDir, config, options, projectInfo) => {
+	const startTime = performance.now();
 	const showHeader = options.showHeader !== false;
 	const useLiveProgress = !options.json && shouldUseSpinner();
-	const projectInfo = await discoverProject(resolvedDir);
 	let files;
 	if (options.staged) {
 		files = filterProjectFiles(resolvedDir, getStagedFiles(resolvedDir), [], config.exclude);
@@ -6381,28 +6678,27 @@ const scanCommand = async (directory, config, options) => {
 	const elapsedMs = performance.now() - startTime;
 	const scoreResult = calculateScore(allDiagnostics, config.scoring.weights, config.scoring.thresholds, projectInfo.sourceFileCount, config.scoring.smoothing);
 	const exitCode = allDiagnostics.some((d) => d.severity === "error") || scoreResult.score < config.ci.failBelow ? 1 : 0;
-	if (!isTelemetryDisabled(config.telemetry?.enabled)) {
-		const engineIssues = {};
-		const engineTimings = {};
-		for (const r of results) {
-			engineIssues[r.engine] = r.diagnostics.length;
-			engineTimings[r.engine] = Math.round(r.elapsed);
-		}
-		trackEvent({
-			command: options.command ?? "scan",
-			languages: projectInfo.languages,
-			scoreBucket: getScoreBucket(scoreResult.score),
-			engineIssues,
-			engineTimings,
-			elapsedMs: Math.round(elapsedMs),
-			fileCount: projectInfo.sourceFileCount
-		});
-	}
+	const engineIssues = {};
+	const engineTimings = {};
+	for (const r of results) {
+		engineIssues[r.engine] = r.diagnostics.length;
+		engineTimings[r.engine] = Math.round(r.elapsed);
+	}
+	const completion = {
+		exitCode,
+		score: scoreResult.score,
+		findingCount: allDiagnostics.length,
+		errorCount: allDiagnostics.filter((d) => d.severity === "error").length,
+		warningCount: allDiagnostics.filter((d) => d.severity === "warning").length,
+		fixableCount: allDiagnostics.filter((d) => d.fixable).length,
+		engineIssues,
+		engineTimings
+	};
 	if (options.json) {
-		const { buildJsonOutput } = await import("./json-D8h2EZW6.js");
+		const { buildJsonOutput } = await import("./json-DZfGz2xa.js");
 		const jsonOut = buildJsonOutput(results, scoreResult, projectInfo.sourceFileCount, elapsedMs);
 		console.log(JSON.stringify(jsonOut, null, 2));
-		return { exitCode };
+		return completion;
 	}
 	const projectName = projectInfo.projectName ?? "project";
 	const language = projectInfo.languages[0] ?? "unknown";
@@ -6419,7 +6715,7 @@ const scanCommand = async (directory, config, options) => {
 		includeHeader: showHeader,
 		printBrand: options.printBrand
 	}));
-	return { exitCode };
+	return completion;
 };
 
 //#endregion
@@ -7764,15 +8060,23 @@ const fixCommand = async (directory, config, options = {
 	verbose: false,
 	showHeader: true
 }) => {
-	const startTime = performance.now();
 	const resolvedDir = path.resolve(directory);
 	if (!fs.existsSync(resolvedDir) || !fs.statSync(resolvedDir).isDirectory()) {
 		const msg = !fs.existsSync(resolvedDir) ? `Path does not exist: ${resolvedDir}` : `Not a directory: ${resolvedDir}`;
 		log.error(msg);
 		return;
 	}
-	const showHeader = options.showHeader !== false;
 	const projectInfo = await discoverProject(resolvedDir);
+	await withCommandLifecycle({
+		command: "fix",
+		config: config.telemetry,
+		languages: projectInfo.languages,
+		fileCount: projectInfo.sourceFileCount
+	}, () => runFixBody(resolvedDir, config, options, projectInfo));
+};
+const runFixBody = async (resolvedDir, config, options, projectInfo) => {
+	const startTime = performance.now();
+	const showHeader = options.showHeader !== false;
 	const projectName = projectInfo.projectName ?? "project";
 	if (showHeader) process.stdout.write(renderHeader({
 		version: APP_VERSION,
@@ -7809,12 +8113,6 @@ const fixCommand = async (directory, config, options = {
 	await runFormattingStep(pipelineDeps);
 	await runForceSteps(pipelineDeps);
 	const totalResolved = steps.reduce((sum, s) => sum + s.resolvedIssues, 0);
-	if (!isTelemetryDisabled(config.telemetry?.enabled)) trackEvent({
-		command: "fix",
-		languages: projectInfo.languages,
-		fixSteps: steps.length,
-		fixResolved: totalResolved
-	});
 	const configDir = findConfigDir(resolvedDir);
 	const rulesPath = configDir ? path.join(configDir, RULES_FILE) : void 0;
 	const engineConfig = {
@@ -7837,7 +8135,9 @@ const fixCommand = async (directory, config, options = {
 	});
 	const allDiagnostics = scanResults.flatMap((r) => r.diagnostics);
 	const scoreResult = calculateScore(allDiagnostics, config.scoring.weights, config.scoring.thresholds, projectInfo.sourceFileCount, config.scoring.smoothing);
-	const remaining = allDiagnostics.filter((d) => d.severity === "error").length + allDiagnostics.filter((d) => d.severity === "warning").length;
+	const errors = allDiagnostics.filter((d) => d.severity === "error").length;
+	const warnings = allDiagnostics.filter((d) => d.severity === "warning").length;
+	const remaining = errors + warnings;
 	if (steps.length === 0) rail.complete({
 		status: "skipped",
 		label: "No applicable auto-fixers found"
@@ -7866,12 +8166,31 @@ const fixCommand = async (directory, config, options = {
 	}
 	if (options.agent) {
 		launchAgent(options.agent, resolvedDir, allDiagnostics, scoreResult.score);
-		return;
+		return {
+			exitCode: 0,
+			score: scoreResult.score,
+			fixSteps: steps.length,
+			fixResolved: totalResolved
+		};
 	}
 	if (options.prompt) {
 		printPrompt(resolvedDir, allDiagnostics, scoreResult.score);
-		return;
+		return {
+			exitCode: 0,
+			score: scoreResult.score,
+			fixSteps: steps.length,
+			fixResolved: totalResolved
+		};
 	}
+	return {
+		exitCode: 0,
+		score: scoreResult.score,
+		findingCount: allDiagnostics.length,
+		errorCount: errors,
+		warningCount: warnings,
+		fixSteps: steps.length,
+		fixResolved: totalResolved
+	};
 };
 
 //#endregion

package/dist/{json-D8h2EZW6.js → json-DZfGz2xa.js}

@@ -1,4 +1,4 @@
-import { n as ENGINE_INFO, t as APP_VERSION } from "./version-BynHxO1X.js";
+import { n as ENGINE_INFO, t as APP_VERSION } from "./version-D_rqBdyj.js";
 
 //#region src/output/json.ts
 const buildJsonOutput = (results, scoreResult, fileCount, elapsedMs) => {

package/dist/{json-BbMwrgyd.js → json-OIzja7OM.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as ENGINE_INFO, t as APP_VERSION } from "./cli.js";
+import { r as APP_VERSION, t as ENGINE_INFO } from "./cli.js";
 
 //#region src/output/json.ts
 const buildJsonOutput = (results, scoreResult, fileCount, elapsedMs) => {