pi-jscpd 0.2.0 → 0.2.2

package/src/extension.ts

@@ -70,6 +70,7 @@ import {
 } from "./status.js";
 import { renderJscpdToolCall, renderJscpdToolResult } from "./tool-render.js";
 import type { JscpdCommandExecutor, JscpdDispatchResult } from "./types.js";
+import { createJscpdUpdateNoticeService, type JscpdUpdateNoticeService } from "./update-notice.js";
 import { createJscpdVerificationService, type JscpdVerificationService } from "./verification.js";
 
 type JscpdToolDefinition = ToolDefinition<typeof jscpdRunParams, JscpdDispatchResult>;
@@ -91,6 +92,7 @@ export interface JscpdExtensionOptions {
   overlayLauncher?: JscpdOverlayLauncher;
   verificationService?: JscpdVerificationService;
   fallowCoexistenceService?: JscpdFallowCoexistenceService;
+  updateNoticeService?: JscpdUpdateNoticeService;
 }
 
 export function registerJscpdExtension(
@@ -117,6 +119,7 @@ export function registerJscpdExtension(
   const configService = options.configService ?? createJscpdConfigService();
   const fallowCoexistence =
     options.fallowCoexistenceService ?? createJscpdFallowCoexistenceService();
+  const updateNotice = options.updateNoticeService ?? createJscpdUpdateNoticeService();
   const startOwnedBaseline = (context: JscpdBaselineStartContext): void => {
     const started = startBaselineQuietly(runtime, baselineService, context);
     baselineSettlement = Promise.all([baselineSettlement, started]).then(() => undefined);
@@ -211,7 +214,10 @@ export function registerJscpdExtension(
   );
 
   pi.on("session_start", async (_event, ctx) => {
-    if (ctx.mode === "tui") installJscpdAutocompleteProvider(ctx.ui);
+    if (ctx.mode === "tui") {
+      installJscpdAutocompleteProvider(ctx.ui);
+      scheduleJscpdUpdateNotice(runtime, updateNotice, ctx);
+    }
     runtime.runSync(scheduler.resetEffect);
     fallowCoexistence.reset();
     verificationService?.reset();
@@ -369,6 +375,20 @@ export function registerJscpdExtension(
   });
 }
 
+function scheduleJscpdUpdateNotice(
+  runtime: JscpdEffectRuntime,
+  service: JscpdUpdateNoticeService,
+  context: ExtensionContext,
+): void {
+  void runtime.runPromiseExit(
+    service.noticeEffect.pipe(
+      Effect.flatMap((message) =>
+        message ? Effect.sync(() => context.ui.notify(message, "warning")) : Effect.void,
+      ),
+    ),
+  );
+}
+
 function requestAutomaticCheck(
   runtime: JscpdEffectRuntime,
   pi: ExtensionAPI,

package/src/jscpd-report.ts

@@ -24,14 +24,17 @@ export const JSCPD_STRUCTURED_REPORTER = "json";
 export const JSCPD_STRUCTURED_REPORT_FILE_NAME = "jscpd-report.json";
 
 const MAX_REPORT_BYTES = 16 * 1_024 * 1_024;
-const MAX_CLONE_PAIRS = 1_000;
+/** Retained, path-resolved pairs kept in session memory. jscpd totals may be larger. */
+export const JSCPD_MAX_DECODED_CLONE_PAIRS = 1_000;
+const MAX_CLONE_PAIRS = JSCPD_MAX_DECODED_CLONE_PAIRS;
 const MAX_FORMATS = 256;
 const MAX_PATH_BYTES = 4_096;
 const MAX_FORMAT_BYTES = 128;
 const MAX_DATE_BYTES = 128;
 const MAX_U32 = 0xffff_ffff;
 const MAX_JSON_DEPTH = 64;
-const MAX_JSON_KEYS = 100_000;
+/** Secondary to the 16 MiB report cap; large trees have many small JSON keys. */
+const MAX_JSON_KEYS = 1_000_000;
 const MAX_JSON_KEYS_PER_OBJECT = 2_048;
 const PATH_RESOLUTION_CONCURRENCY = 16;
 
@@ -151,13 +154,14 @@ function parseReportBytes(bytes: Uint8Array): ParsedReport {
     requiredProperty(topLevel, "duplicates", "invalid-top-level"),
     "invalid-duplicates",
   );
-  if (duplicates.length > MAX_CLONE_PAIRS) {
-    fail("limit-exceeded");
-  }
-
-  const clonePairs = duplicates.map(parseClonePair);
   const statistics = parseStatistics(requiredProperty(topLevel, "statistics", "invalid-top-level"));
-  validateCloneStatistics(clonePairs, statistics);
+  if (statistics.total.clones !== duplicates.length) {
+    fail("invalid-statistics");
+  }
+  const truncated = duplicates.length > MAX_CLONE_PAIRS;
+  const retained = truncated ? duplicates.slice(0, MAX_CLONE_PAIRS) : duplicates;
+  const clonePairs = retained.map(parseClonePair);
+  validateCloneStatistics(clonePairs, statistics, truncated);
   return { statistics, clonePairs };
 }
 
@@ -402,7 +406,14 @@ function parseStatisticsRow(value: unknown): JscpdStatisticsRow {
 function validateCloneStatistics(
   clonePairs: readonly UnresolvedClonePair[],
   statistics: JscpdScanStatistics,
+  truncated: boolean,
 ): void {
+  if (truncated) {
+    if (clonePairs.length !== MAX_CLONE_PAIRS || statistics.total.clones < clonePairs.length) {
+      fail("invalid-statistics");
+    }
+    return;
+  }
   if (statistics.total.clones !== clonePairs.length) {
     fail("invalid-statistics");
   }

package/src/presentation.ts

@@ -28,11 +28,11 @@ export function presentJscpdScan(
     .slice(0, Math.max(maxFindings, overlayLimit ?? 0))
     .map(presentFinding);
   const findings = Object.freeze(retained.slice(0, maxFindings));
-  const omittedFindings = Math.max(0, report.clonePairs.length - findings.length);
+  const omittedFindings = Math.max(0, summary.clones - findings.length);
   const overlayCache = overlayLimit
     ? Object.freeze({
         findings: Object.freeze(retained.slice(0, overlayLimit)),
-        omittedFindings: Math.max(0, report.clonePairs.length - overlayLimit),
+        omittedFindings: Math.max(0, summary.clones - overlayLimit),
       })
     : undefined;
   const outcome = findings.length === 0 ? "clean" : "findings";

package/src/update-notice.ts

@@ -0,0 +1,194 @@
+import { readFile } from "node:fs/promises";
+import { get } from "node:https";
+import { Effect } from "effect";
+
+const PACKAGE_NAME = "pi-jscpd";
+const PACKAGE_JSON_URL = new URL("../package.json", import.meta.url);
+const NPM_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const UPDATE_COMMAND = `pi update npm:${PACKAGE_NAME}`;
+const DISABLE_UPDATE_ENV = "PI_JSCPD_DISABLE_UPDATE_NOTICE";
+const UPDATE_CHECK_ENV = "PI_JSCPD_UPDATE_CHECK";
+const UPDATE_CHECK_TIMEOUT_MS = 1_500;
+const MAX_RESPONSE_BYTES = 16 * 1_024;
+const VERSION_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+interface JscpdUpdateNoticeOptions {
+  readonly environment?: Readonly<Record<string, string | undefined>>;
+  readonly currentVersionEffect?: Effect.Effect<string | undefined, unknown>;
+  readonly latestVersionEffect?: Effect.Effect<string | undefined, unknown>;
+  readonly timeoutMs?: number;
+}
+
+export interface JscpdUpdateNoticeService {
+  /** Resolve at most one warning for this extension instance; failures stay silent. */
+  readonly noticeEffect: Effect.Effect<string | undefined>;
+}
+
+/** Best-effort npm metadata check. It never downloads or installs package content. */
+export function createJscpdUpdateNoticeService(
+  options: JscpdUpdateNoticeOptions = {},
+): JscpdUpdateNoticeService {
+  const environment = options.environment ?? process.env;
+  let shown = false;
+
+  return {
+    noticeEffect: Effect.suspend(() => {
+      if (shown || isUpdateCheckDisabled(environment)) return Effect.succeed(undefined);
+      shown = true;
+
+      const currentVersion = recoverLookup(
+        options.currentVersionEffect ?? readCurrentVersionEffect(),
+      );
+      const latestVersion = recoverLookup(
+        options.latestVersionEffect ?? fetchLatestVersionEffect(),
+      ).pipe(
+        Effect.timeoutTo({
+          duration: options.timeoutMs ?? UPDATE_CHECK_TIMEOUT_MS,
+          onSuccess: (version) => version,
+          onTimeout: () => undefined,
+        }),
+      );
+
+      return currentVersion.pipe(
+        Effect.flatMap((current) =>
+          current
+            ? latestVersion.pipe(Effect.map((latest) => buildUpdateNotice(current, latest)))
+            : Effect.succeed(undefined),
+        ),
+      );
+    }),
+  };
+}
+
+function readCurrentVersionEffect(): Effect.Effect<string | undefined, Error> {
+  return Effect.tryPromise({
+    try: () => readFile(PACKAGE_JSON_URL, "utf8"),
+    catch: () => new Error("Unable to read package metadata."),
+  }).pipe(Effect.map(parsePackageVersion));
+}
+
+function parsePackageVersion(source: string): string | undefined {
+  try {
+    const value = JSON.parse(source) as { version?: unknown };
+    return typeof value.version === "string" && VERSION_PATTERN.test(value.version)
+      ? value.version
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function fetchLatestVersionEffect(): Effect.Effect<string | undefined, Error> {
+  return Effect.async((resume) => {
+    let settled = false;
+    const settle = (effect: Effect.Effect<string | undefined, Error>): void => {
+      if (settled) return;
+      settled = true;
+      resume(effect);
+    };
+    const request = get(NPM_LATEST_URL, { headers: { accept: "application/json" } }, (response) => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        settle(Effect.succeed(undefined));
+        return;
+      }
+
+      const declaredLength = Number(response.headers["content-length"]);
+      if (Number.isFinite(declaredLength) && declaredLength > MAX_RESPONSE_BYTES) {
+        response.destroy();
+        settle(Effect.succeed(undefined));
+        return;
+      }
+
+      const chunks: Uint8Array[] = [];
+      let total = 0;
+      response.on("data", (value: Buffer) => {
+        total += value.byteLength;
+        if (total > MAX_RESPONSE_BYTES) {
+          response.destroy();
+          settle(Effect.succeed(undefined));
+          return;
+        }
+        chunks.push(value);
+      });
+      response.once("end", () => {
+        settle(Effect.succeed(parseLatestVersionBytes(chunks, total)));
+      });
+      response.once("error", () => {
+        settle(Effect.fail(new Error("Unable to read npm package metadata.")));
+      });
+    });
+    request.once("error", () => {
+      settle(Effect.fail(new Error("Unable to check npm package metadata.")));
+    });
+
+    return Effect.sync(() => {
+      settled = true;
+      request.destroy();
+    });
+  });
+}
+
+function parseLatestVersionBytes(chunks: readonly Uint8Array[], total: number): string | undefined {
+  try {
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const value = JSON.parse(source) as { version?: unknown };
+    return typeof value.version === "string" && VERSION_PATTERN.test(value.version)
+      ? value.version
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function recoverLookup(
+  effect: Effect.Effect<string | undefined, unknown>,
+): Effect.Effect<string | undefined> {
+  return effect.pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+}
+
+function buildUpdateNotice(
+  currentVersion: string,
+  latestVersion: string | undefined,
+): string | undefined {
+  if (!latestVersion || compareVersions(latestVersion, currentVersion) <= 0) return undefined;
+  return `${PACKAGE_NAME} ${latestVersion} is available (you have ${currentVersion}). Update: ${UPDATE_COMMAND}`;
+}
+
+function compareVersions(left: string, right: string): number {
+  const leftMatch = VERSION_PATTERN.exec(left);
+  const rightMatch = VERSION_PATTERN.exec(right);
+  if (!leftMatch || !rightMatch) return 0;
+
+  for (let index = 1; index <= 3; index += 1) {
+    const difference = Number(leftMatch[index]) - Number(rightMatch[index]);
+    if (difference !== 0) return Math.sign(difference);
+  }
+
+  const leftPrerelease = left.includes("-");
+  const rightPrerelease = right.includes("-");
+  if (leftPrerelease === rightPrerelease) return 0;
+  return leftPrerelease ? -1 : 1;
+}
+
+function isUpdateCheckDisabled(environment: Readonly<Record<string, string | undefined>>): boolean {
+  const offline = environment.PI_OFFLINE;
+  if (offline !== undefined && !isFalseLike(offline)) return true;
+
+  const disabled = environment[DISABLE_UPDATE_ENV];
+  if (disabled !== undefined) return !isFalseLike(disabled);
+
+  const enabled = environment[UPDATE_CHECK_ENV];
+  return enabled !== undefined && isFalseLike(enabled);
+}
+
+function isFalseLike(value: string): boolean {
+  return ["0", "false", "off", "no"].includes(value.toLocaleLowerCase());
+}