Merge pull request 'New features, improvements and fixes' (#18) from feat/polish-first into main

Reviewed-on: https://gitea.renux.dev/renux/project-actions/pulls/18

Author: dantesCode

.gitignore

@@ -3,6 +3,7 @@ node_modules/
 *.vsix
 !releases/*.vsix
 .vscode-test/
+package-lock.json
 .claude/
 .agents/
 docs/

.vscodeignore

@@ -13,3 +13,5 @@ node_modules/**
 .agents/**
 .claude/**
 .opencode/**
+benchmarks/**
+scripts/**

README.md

@@ -0,0 +1,156 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { benchmark } from "./lib/timing";
+import { printTable } from "./lib/format";
+import { detectors } from "../src/detectors/index";
+
+function createFixtures(root: string) {
+  fs.mkdirSync(root, { recursive: true });
+
+  const pkgScripts: Record<string, string> = {};
+  for (let i = 1; i <= 20; i++) {
+    pkgScripts[`script-${i}`] = `echo ${i}`;
+  }
+  fs.writeFileSync(
+    path.join(root, "package.json"),
+    JSON.stringify({ name: "test", scripts: pkgScripts }, null, 2),
+  );
+  fs.writeFileSync(path.join(root, "bun.lock"), "");
+
+  const composerScripts: Record<string, string> = {};
+  for (let i = 1; i <= 10; i++) {
+    composerScripts[`script-${i}`] = `echo ${i}`;
+  }
+  fs.writeFileSync(
+    path.join(root, "composer.json"),
+    JSON.stringify({ scripts: composerScripts }, null, 2),
+  );
+
+  const makeTargets: string[] = [];
+  for (let i = 1; i <= 50; i++) {
+    makeTargets.push(`target-${i}`);
+  }
+  const makefileLines: string[] = [
+    `.PHONY: ${makeTargets.join(" ")}`,
+    ...makeTargets.map((t) => `${t}:\n\techo ${t}`),
+  ];
+  fs.writeFileSync(path.join(root, "Makefile"), makefileLines.join("\n"));
+
+  const rakeTasks: string[] = [];
+  for (let i = 1; i <= 15; i++) {
+    rakeTasks.push(`task :task-${i}`);
+  }
+  fs.writeFileSync(path.join(root, "Rakefile"), rakeTasks.join("\n"));
+
+  const profiles: string[] = [];
+  for (let i = 1; i <= 5; i++) {
+    profiles.push(`<profile><id>profile-${i}</id></profile>`);
+  }
+  fs.writeFileSync(
+    path.join(root, "pom.xml"),
+    `<project>\n  <profiles>\n    ${profiles.join("\n    ")}\n  </profiles>\n</project>`,
+  );
+
+  const gradleTasks: string[] = [];
+  for (let i = 1; i <= 10; i++) {
+    const q = i % 3 === 0 ? '"' : i % 3 === 1 ? "'" : "";
+    gradleTasks.push(`task ${q}custom-${i}${q}`);
+  }
+  fs.writeFileSync(path.join(root, "build.gradle"), gradleTasks.join("\n"));
+
+  const cargoLines: string[] = [
+    "[package]",
+    'name = "pkg"',
+    'version = "0.1.0"',
+    "",
+    "[[bin]]",
+    'name = "bin1"',
+    "",
+    "[[bin]]",
+    'name = "bin2"',
+    "",
+    "[[example]]",
+    'name = "ex1"',
+    "",
+    "[[example]]",
+    'name = "ex2"',
+    "",
+    "[[test]]",
+    'name = "t1"',
+    "",
+    "[[test]]",
+    'name = "t2"',
+    "",
+    "[[bench]]",
+    'name = "b1"',
+    "",
+    "[workspace]",
+    'members = ["member-a", "member-b", "member-c"]',
+  ];
+  fs.writeFileSync(path.join(root, "Cargo.toml"), cargoLines.join("\n"));
+
+  fs.writeFileSync(path.join(root, "go.mod"), "module example.com/test\ngo 1.21");
+  for (const name of ["server", "worker", "cli"]) {
+    const dir = path.join(root, "cmd", name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "main.go"), "package main\n");
+  }
+
+  const pyprojectLines: string[] = [
+    "[build-system]",
+    'requires = ["setuptools"]',
+    "",
+    "[tool.pytest.ini_options]",
+    'minversion = "7.0"',
+    "",
+    "[tool.tox]",
+    'env_list = ["py311"]',
+    "",
+    "[project.scripts]",
+    's1 = "m1:main"',
+    's2 = "m2:main"',
+    's3 = "m3:main"',
+    's4 = "m4:main"',
+    's5 = "m5:main"',
+  ];
+  fs.writeFileSync(path.join(root, "pyproject.toml"), pyprojectLines.join("\n"));
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "benchmark-detectors-"));
+  createFixtures(root);
+
+  const rows: {
+    name: string;
+    min: number;
+    max: number;
+    mean: number;
+    p50: number;
+    p95: number;
+    p99: number;
+  }[] = [];
+  for (const detector of detectors) {
+    const stats = await benchmark(() => detector.detect(root), { warmup: 5, iterations: 100 });
+    rows.push({ name: detector.id, ...stats });
+  }
+
+  const parallelStats = await benchmark(() => Promise.all(detectors.map((d) => d.detect(root))), {
+    warmup: 5,
+    iterations: 100,
+  });
+  rows.push({ name: "all-parallel", ...parallelStats });
+
+  printTable(
+    "Detector Performance (100 runs each, in µs)",
+    ["name", "min", "max", "mean", "p50", "p95", "p99"],
+    rows,
+  );
+
+  fs.rmSync(root, { recursive: true });
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

benchmarks/detectors.ts

@@ -0,0 +1,42 @@
+export function formatSize(bytes: number): string {
+  if (bytes === 0) {
+    return "0.0 KB";
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(1)} KB`;
+  }
+  const mb = kb / 1024;
+  if (mb < 1024) {
+    return `${mb.toFixed(1)} MB`;
+  }
+  return `${(mb / 1024).toFixed(1)} GB`;
+}
+
+export function printTable(
+  title: string,
+  headers: string[],
+  rows: Record<string, string | number>[],
+): void {
+  const colWidths = headers.map((h) => {
+    const headerLen = h.length;
+    const maxValLen = Math.max(...rows.map((r) => String(r[h]).length));
+    return Math.max(headerLen, maxValLen);
+  });
+
+  const totalWidth = colWidths.reduce((a, b) => a + b, 0) + (colWidths.length - 1) * 2;
+
+  console.log(title);
+  console.log("─".repeat(totalWidth));
+  console.log(
+    headers.map((h, i) => (i === 0 ? h.padEnd(colWidths[i]) : h.padStart(colWidths[i]))).join("  "),
+  );
+  for (const row of rows) {
+    const cells = headers.map((h, i) => {
+      const val = String(row[h]);
+      return i === 0 ? val.padEnd(colWidths[i]) : val.padStart(colWidths[i]);
+    });
+    console.log(cells.join("  "));
+  }
+  console.log("─".repeat(totalWidth));
+}

benchmarks/lib/format.ts

@@ -0,0 +1,41 @@
+export interface Stats {
+  min: number;
+  max: number;
+  mean: number;
+  p50: number;
+  p95: number;
+  p99: number;
+}
+
+export function computeStats(timings: number[]): Stats {
+  const sorted = [...timings].sort((a, b) => a - b);
+  const min = sorted[0];
+  const max = sorted[sorted.length - 1];
+  const mean = sorted.reduce((a, b) => a + b, 0) / sorted.length;
+  const percentile = (p: number) => sorted[Math.ceil(p * sorted.length) - 1];
+  return {
+    min: Math.round(min),
+    max: Math.round(max),
+    mean: Math.round(mean),
+    p50: Math.round(percentile(0.5)),
+    p95: Math.round(percentile(0.95)),
+    p99: Math.round(percentile(0.99)),
+  };
+}
+
+export async function benchmark(
+  fn: () => void | Promise<void>,
+  options: { warmup: number; iterations: number },
+): Promise<Stats> {
+  for (let i = 0; i < options.warmup; i++) {
+    await fn();
+  }
+  const timings: number[] = [];
+  for (let i = 0; i < options.iterations; i++) {
+    const start = process.hrtime.bigint();
+    await fn();
+    const elapsed = Number(process.hrtime.bigint() - start) / 1000;
+    timings.push(elapsed);
+  }
+  return computeStats(timings);
+}

benchmarks/lib/timing.ts

@@ -0,0 +1,75 @@
+import * as fs from "fs";
+import * as path from "path";
+import { formatSize } from "./lib/format";
+
+const root = process.cwd();
+
+function getFileSize(filePath: string): number {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+function getDirSize(dirPath: string): number {
+  let total = 0;
+  try {
+    const entries = fs.readdirSync(dirPath, { recursive: true }) as string[];
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry);
+      const stat = fs.statSync(fullPath);
+      if (stat.isFile()) {
+        total += stat.size;
+      }
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+}
+
+function getVsixFiles(): { name: string; size: number }[] {
+  try {
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && e.name.endsWith(".vsix"))
+      .map((e) => ({ name: e.name, size: getFileSize(path.join(root, e.name)) }));
+  } catch {
+    return [];
+  }
+}
+
+const extensionJsSize = getFileSize(path.join(root, "out", "extension.js"));
+const vsixFiles = getVsixFiles();
+const outDirSize = getDirSize(path.join(root, "out"));
+const nodeModulesSize = getDirSize(path.join(root, "node_modules"));
+
+const rows: { label: string; size: number; note?: string }[] = [
+  { label: "out/extension.js", size: extensionJsSize },
+];
+
+if (vsixFiles.length === 0) {
+  rows.push({ label: "VSIX", size: 0, note: "none" });
+} else {
+  for (const v of vsixFiles) {
+    rows.push({ label: "VSIX", size: v.size, note: v.name });
+  }
+}
+
+rows.push({ label: "out/ total", size: outDirSize });
+rows.push({ label: "node_modules/", size: nodeModulesSize });
+
+const maxLabel = Math.max(...rows.map((r) => r.label.length));
+const divider = "─".repeat(44);
+
+console.log("Bundle Size Report");
+console.log(divider);
+
+for (const row of rows) {
+  let line = row.label.padEnd(maxLabel + 4) + formatSize(row.size);
+  if (row.note) {
+    line += `  (${row.note})`;
+  }
+  console.log(line);
+}