@apmantza/greedysearch-pi 2.1.3 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apmantza/greedysearch-pi",
-	"version": "2.1.3",
+	"version": "2.1.5",
 	"description": "Headless multi-engine AI search (Perplexity, Google AI, ChatGPT, Gemini) via browser automation. NO API KEYS needed. Grounded all-engine search fetches sources by default, with optional configurable synthesis and deep research.",
 	"type": "module",
 	"keywords": [
@@ -21,8 +21,17 @@
 		"test:bash": "./test.sh",
 		"test:bash:quick": "./test.sh quick",
 		"test:bash:smoke": "./test.sh smoke",
+		"stealth-check": "node scripts/stealth-check.mjs",
+		"stealth:check": "node scripts/stealth-check.mjs",
+		"stealth:strict": "node scripts/stealth-check.mjs --strict",
+		"stealth:diff": "node scripts/stealth-check.mjs --diff",
+		"stealth:baseline": "node scripts/stealth-check.mjs --diff",
 		"lint": "node scripts/lint.mjs",
-		"check:lockfile": "node scripts/check-lockfile.mjs"
+		"check:lockfile": "node scripts/check-lockfile.mjs",
+		"changelog:check": "node scripts/changelog-release.mjs --check",
+		"changelog:release": "node scripts/changelog-release.mjs",
+		"changelog:extract": "node scripts/changelog-extract.mjs",
+		"release:backfill-notes": "node scripts/backfill-github-releases.mjs"
 	},
 	"engines": {
 		"node": ">=20.11.0"
@@ -32,18 +41,15 @@
 		"test.mjs",
 		"bin/",
 		"src/",
-		"skills/",
 		"extractors/",
+		"scripts/",
 		"CHANGELOG.md",
 		"README.md",
-		"docs/banner.png"
+		"docs/"
 	],
 	"pi": {
 		"extensions": [
 			"./index.ts"
-		],
-		"skills": [
-			"./skills"
 		]
 	},
 	"dependencies": {

package/scripts/backfill-github-releases.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+// Retroactively set GitHub release bodies to their curated CHANGELOG sections.
+//
+//   node scripts/backfill-github-releases.mjs                 # dry run
+//   node scripts/backfill-github-releases.mjs --apply         # edit releases
+//   node scripts/backfill-github-releases.mjs --apply --full  # use full prose
+//   node scripts/backfill-github-releases.mjs --only v2.1.3,v2.1.2 --apply
+//   node scripts/backfill-github-releases.mjs --repo owner/repo --apply
+//
+// Requires the `gh` CLI authenticated with permission to edit releases.
+
+import { readFileSync, writeFileSync, mkdtempSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { platform, tmpdir } from "node:os";
+import {
+	extractSection,
+	normalizeVersion,
+	summarizeSection,
+} from "./lib/changelog.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CHANGELOG_PATH = join(__dirname, "..", "CHANGELOG.md");
+
+function parseArgs(argv) {
+	const args = { apply: false, full: false, repo: undefined, only: undefined };
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === "--apply") args.apply = true;
+		else if (a === "--full") args.full = true;
+		else if (a === "--repo") args.repo = argv[++i];
+		else if (a === "--only") {
+			args.only = new Set(
+				argv[++i].split(",").map((s) => normalizeVersion(s.trim())),
+			);
+		}
+	}
+	return args;
+}
+
+function resolveGh() {
+	const candidates =
+		platform() === "win32"
+			? [
+					"C:\\Program Files\\GitHub CLI\\gh.exe",
+					"C:\\Program Files (x86)\\GitHub CLI\\gh.exe",
+				]
+			: ["/usr/bin/gh", "/usr/local/bin/gh", "/opt/homebrew/bin/gh"];
+	for (const candidate of candidates) {
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error("GitHub CLI not found in trusted install locations");
+}
+
+const GH = resolveGh();
+
+function gh(args) {
+	return execFileSync(GH, args, { encoding: "utf8" });
+}
+
+function listReleases(repo) {
+	const args = ["release", "list", "--limit", "200", "--json", "tagName"];
+	if (repo) args.push("--repo", repo);
+	const raw = gh(args);
+	try {
+		return JSON.parse(raw).map((r) => r.tagName);
+	} catch (err) {
+		throw new Error(`Invalid JSON from gh release list: ${err.message || err}`);
+	}
+}
+
+function main() {
+	const args = parseArgs(process.argv.slice(2));
+	const changelog = readFileSync(CHANGELOG_PATH, "utf8");
+
+	let tags;
+	try {
+		tags = listReleases(args.repo);
+	} catch (err) {
+		console.error(
+			"Failed to list releases via `gh`. Is it installed and authenticated?",
+		);
+		console.error(String(err.message || err));
+		process.exit(1);
+	}
+
+	const tmp = mkdtempSync(join(tmpdir(), "greedysearch-relnotes-"));
+	const plan = [];
+	for (const tag of tags) {
+		if (args.only && !args.only.has(normalizeVersion(tag))) continue;
+		const full = extractSection(changelog, tag);
+		if (full === null || full.trim().length === 0) {
+			plan.push({ tag, action: "skip", reason: "no CHANGELOG section" });
+			continue;
+		}
+		const body = args.full ? full : summarizeSection(full);
+		if (!body.trim()) {
+			plan.push({ tag, action: "skip", reason: "empty summarized notes" });
+			continue;
+		}
+		plan.push({ tag, action: "update", body });
+	}
+
+	const updates = plan.filter((p) => p.action === "update");
+	const skips = plan.filter((p) => p.action === "skip");
+
+	console.log(
+		`${args.apply ? "APPLYING" : "DRY RUN"} — ${updates.length} release(s) to update, ${skips.length} skipped.\n`,
+	);
+	for (const p of skips) console.log(`  skip   ${p.tag}  (${p.reason})`);
+	for (const p of updates) {
+		const firstLine = p.body.split("\n").find((l) => l.trim()) ?? "";
+		console.log(`  update ${p.tag}  ${firstLine.slice(0, 70)}`);
+	}
+
+	if (!args.apply) {
+		console.log("\nRe-run with --apply to write these release bodies.");
+		return;
+	}
+
+	let ok = 0;
+	for (const p of updates) {
+		const notesFile = join(tmp, `${normalizeVersion(p.tag)}.md`);
+		writeFileSync(notesFile, `${p.body}\n`, "utf8");
+		const editArgs = ["release", "edit", p.tag, "--notes-file", notesFile];
+		if (args.repo) editArgs.push("--repo", args.repo);
+		try {
+			gh(editArgs);
+			ok++;
+			console.log(`  ok     ${p.tag}`);
+		} catch (err) {
+			console.error(`  FAIL   ${p.tag}: ${String(err.message || err)}`);
+		}
+	}
+	console.log(`\nUpdated ${ok}/${updates.length} release bodies.`);
+}
+
+main();

package/scripts/changelog-extract.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// Print the curated CHANGELOG.md section body for a version.
+//
+//   node scripts/changelog-extract.mjs 2.1.3
+//   node scripts/changelog-extract.mjs v2.1.3 --summary -o RELEASE_NOTES.md
+//
+// The release workflow uses this to make GitHub release notes come from the
+// curated changelog instead of auto-generated commit/PR titles.
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { extractSection, summarizeSection } from "./lib/changelog.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CHANGELOG_PATH = join(__dirname, "..", "CHANGELOG.md");
+
+function parseArgs(argv) {
+	const args = { version: undefined, out: undefined, summary: false };
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === "-o" || a === "--out") args.out = argv[++i];
+		else if (a === "--summary") args.summary = true;
+		else if (!args.version) args.version = a;
+	}
+	return args;
+}
+
+function main() {
+	const { version, out, summary } = parseArgs(process.argv.slice(2));
+	if (!version) {
+		console.error(
+			"usage: changelog-extract.mjs <version> [--summary] [-o <file>]",
+		);
+		process.exit(2);
+	}
+	const text = readFileSync(CHANGELOG_PATH, "utf8");
+	const full = extractSection(text, version);
+	if (full === null || full.trim().length === 0) {
+		console.error(`No CHANGELOG section for version "${version}".`);
+		process.exit(1);
+	}
+	const body = summary ? summarizeSection(full) : full;
+	if (out) writeFileSync(out, `${body}\n`, "utf8");
+	else process.stdout.write(`${body}\n`);
+}
+
+main();

package/scripts/changelog-release.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// Promote the `## [Unreleased]` section to a dated version section and open a
+// fresh empty `## [Unreleased]` above it.
+//
+//   node scripts/changelog-release.mjs            # package.json version, today
+//   node scripts/changelog-release.mjs 2.2.0      # explicit version
+//   node scripts/changelog-release.mjs 2.2.0 --date 2026-07-03
+//   node scripts/changelog-release.mjs --check    # verify Unreleased has entries
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { promoteUnreleased, unreleasedHasEntries } from "./lib/changelog.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CHANGELOG_PATH = join(__dirname, "..", "CHANGELOG.md");
+const PKG_PATH = join(__dirname, "..", "package.json");
+
+function parseArgs(argv) {
+	const args = { version: undefined, date: undefined, check: false };
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === "--check") args.check = true;
+		else if (a === "--date") args.date = argv[++i];
+		else if (!args.version) args.version = a;
+	}
+	return args;
+}
+
+function main() {
+	const args = parseArgs(process.argv.slice(2));
+	const text = readFileSync(CHANGELOG_PATH, "utf8");
+
+	if (args.check) {
+		if (!unreleasedHasEntries(text)) {
+			console.error("`## [Unreleased]` has no entries to release.");
+			process.exit(1);
+		}
+		console.log("[Unreleased] has entries — ready to release.");
+		return;
+	}
+
+	let version = args.version;
+	if (!version) {
+		try {
+			version = JSON.parse(readFileSync(PKG_PATH, "utf8")).version;
+		} catch (err) {
+			console.error(`Failed to read package version: ${err.message || err}`);
+			process.exit(1);
+		}
+	}
+	const date = args.date ?? new Date().toISOString().slice(0, 10);
+
+	let next;
+	try {
+		next = promoteUnreleased(text, version, date);
+	} catch (err) {
+		console.error(String(err.message || err));
+		process.exit(1);
+	}
+	writeFileSync(CHANGELOG_PATH, next, "utf8");
+	console.log(`Promoted [Unreleased] -> [${version}] — ${date}.`);
+}
+
+main();

package/scripts/check-lockfile.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// scripts/check-lockfile.mjs — verify package.json and package-lock.json are in sync.
+// CI fails the lint-and-lockfile job if a dep version is listed in package.json
+// without a matching entry in package-lock.json, or vice versa.
+//
+// Usage:  npm run check:lockfile
+import { readFileSync, existsSync } from "node:fs";
+
+const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+if (!existsSync("package-lock.json")) {
+  console.error("package-lock.json not found. Run `npm install` first.");
+  process.exit(1);
+}
+const lock = JSON.parse(readFileSync("package-lock.json", "utf8"));
+const root = lock.packages?.[""] || {};
+
+let issues = 0;
+const check = (section, name, ver, lockVer) => {
+  if (lockVer !== ver) {
+    console.error(
+      `MISMATCH (${section}): ${name} — package.json: ${ver ?? "(absent)"}, lock: ${lockVer ?? "(absent)"}`,
+    );
+    issues++;
+  }
+};
+
+for (const [name, ver] of Object.entries(pkg.dependencies || {})) {
+  check("dep", name, ver, root.dependencies?.[name]);
+}
+for (const [name, ver] of Object.entries(pkg.devDependencies || {})) {
+  check("devDep", name, ver, root.devDependencies?.[name]);
+}
+
+if (issues) {
+  console.error(
+    `\n${issues} lockfile mismatch(es). Run \`npm install\` to update.`,
+  );
+  process.exit(1);
+}
+const depCount =
+  Object.keys(pkg.dependencies || {}).length +
+  Object.keys(pkg.devDependencies || {}).length;
+console.log(
+  `Lockfile in sync with package.json (${depCount} ${depCount === 1 ? "dep" : "deps"})`,
+);

package/scripts/lib/changelog.mjs

@@ -0,0 +1,168 @@
+// Shared CHANGELOG.md parsing/extraction helpers.
+//
+// The curated CHANGELOG section for a version is the source of truth for the
+// GitHub release body. `changelog-extract.mjs` (release workflow),
+// `changelog-release.mjs` (version-bump helper), and
+// `backfill-github-releases.mjs` (retroactive release body sync) all use these
+// pure helpers so parsing behavior stays identical.
+
+const BRACKET_VERSION_HEADING = /^## \[([^\]]+)\]/;
+const LEGACY_VERSION_HEADING = /^##\s+v?(\d+\.\d+\.\d+)\b/i;
+
+function matchVersionHeading(line) {
+	const bracket = line.match(BRACKET_VERSION_HEADING);
+	if (bracket) return bracket[1].trim();
+	const legacy = line.match(LEGACY_VERSION_HEADING);
+	if (legacy) return legacy[1].trim();
+	return null;
+}
+
+/**
+ * Split CHANGELOG.md into ordered version sections.
+ * Supports both current headings (`## [2.1.3] — 2026-06-21`) and legacy
+ * headings (`## v1.8.5 (2026-04-29)`) so old GitHub releases can be backfilled.
+ *
+ * @param {string} text
+ * @returns {Array<{ label: string, heading: string, body: string }>}
+ */
+export function parseSections(text) {
+	const lines = text.split(/\r?\n/);
+	const sections = [];
+	let current = null;
+	for (const line of lines) {
+		const label = matchVersionHeading(line);
+		if (label) {
+			if (current) sections.push(finalize(current));
+			current = { label, heading: line, bodyLines: [] };
+			continue;
+		}
+		if (current) current.bodyLines.push(line);
+	}
+	if (current) sections.push(finalize(current));
+	return sections;
+}
+
+function finalize(current) {
+	return {
+		label: current.label,
+		heading: current.heading,
+		body: current.bodyLines.join("\n").replace(/^\n+/, "").replace(/\s+$/, ""),
+	};
+}
+
+/**
+ * Condense a section into scannable GitHub release notes. Keeps headings and
+ * top-level bullets, trims verbose bullets to their first sentence when useful,
+ * and supports both `- **Title** — details` and plain legacy bullets.
+ *
+ * @param {string} body
+ * @param {{ maxGist?: number }} [opts]
+ * @returns {string}
+ */
+export function summarizeSection(body, opts = {}) {
+	const maxGist = opts.maxGist ?? 160;
+	const order = [];
+	const buckets = new Map();
+	let heading = null;
+	for (const raw of body.split(/\r?\n/)) {
+		const line = raw.trimEnd();
+		const h = line.match(/^#{2,4}\s+(.*)$/);
+		if (h) {
+			heading = h[1].trim();
+			if (!buckets.has(heading)) {
+				buckets.set(heading, []);
+				order.push(heading);
+			}
+			continue;
+		}
+		if (heading === null) continue;
+		const bold = line.match(/^- (\*\*.+?\*\*)\s*(.*)$/);
+		if (bold) {
+			const gist = cleanGist(bold[2], maxGist);
+			buckets.get(heading).push(gist ? `- ${bold[1]} — ${gist}` : `- ${bold[1]}`);
+			continue;
+		}
+		const plain = line.match(/^-\s+(.+)$/);
+		if (plain) buckets.get(heading).push(`- ${cleanPlainBullet(plain[1], maxGist)}`);
+	}
+	const out = [];
+	for (const h of order) {
+		const items = buckets.get(h);
+		if (!items.length) continue;
+		out.push(`### ${h}`, "", ...items, "");
+	}
+	return out.join("\n").replace(/^\n+/, "").replace(/\s+$/, "");
+}
+
+function cleanGist(rest, maxGist) {
+	const text = rest
+		.replace(/^\s*\((?:refs?|closes?|fixes?)?\s*#\d+\)\s*/i, "")
+		.replace(/^\s*[—–:-]\s*/, "")
+		.trim();
+	if (!text) return "";
+	return firstSentence(text, maxGist);
+}
+
+function cleanPlainBullet(text, maxGist) {
+	return firstSentence(text.trim(), maxGist) || text.trim().slice(0, maxGist);
+}
+
+function firstSentence(text, maxGist) {
+	const period = text.search(/\.\s/);
+	const first = period >= 0 ? text.slice(0, period) : text;
+	return first.length > 0 && first.length <= maxGist ? first : "";
+}
+
+export function normalizeVersion(version) {
+	return String(version).trim().replace(/^v/i, "");
+}
+
+export function extractSection(text, version) {
+	const want = normalizeVersion(version);
+	const section = parseSections(text).find(
+		(s) => normalizeVersion(s.label) === want,
+	);
+	return section ? section.body : null;
+}
+
+export function hasSection(text, version) {
+	const body = extractSection(text, version);
+	return typeof body === "string" && body.trim().length > 0;
+}
+
+export function unreleasedHasEntries(text) {
+	const body = extractSection(text, "Unreleased");
+	return body !== null && /^\s*[-*]\s/m.test(body);
+}
+
+const EMPTY_UNRELEASED = [
+	"## [Unreleased]",
+	"",
+	"### Added",
+	"",
+	"### Changed",
+	"",
+	"### Fixed",
+	"",
+].join("\n");
+
+export function promoteUnreleased(text, version, date) {
+	if (extractSection(text, "Unreleased") === null) {
+		throw new Error("No `## [Unreleased]` section found.");
+	}
+	if (!unreleasedHasEntries(text)) {
+		throw new Error("`## [Unreleased]` has no entries to release.");
+	}
+	if (extractSection(text, version) !== null) {
+		throw new Error(`CHANGELOG already has a section for ${version}.`);
+	}
+
+	const replaced = text.replace(
+		/^## \[Unreleased\][^\n]*$/m,
+		`${EMPTY_UNRELEASED}\n## [${version}] — ${date}`,
+	);
+	if (replaced === text) {
+		throw new Error("Failed to locate the `## [Unreleased]` heading.");
+	}
+	return replaced;
+}

package/scripts/lint.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// scripts/lint.mjs — cross-platform syntax check for all .mjs files in the repo.
+// Uses `node --check` (syntax-only, no module resolution) so it works on
+// every OS without depending on `find`.
+//
+// Usage:  npm run lint
+import { execFileSync } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+const ROOT = process.cwd();
+const SKIP_DIRS = new Set([
+  "node_modules",
+  "results",
+  ".pi",
+  ".git",
+  "coverage",
+  "dist",
+  "out",
+]);
+const SKIP_FILES = new Set([join("scripts", "lint.mjs")]); // self-check is redundant
+const EXT = ".mjs";
+
+function* walk(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walk(full);
+    } else if (entry.name.endsWith(EXT) && !SKIP_FILES.has(full)) {
+      yield full;
+    }
+  }
+}
+
+const files = [...walk(ROOT)];
+if (!files.length) {
+  console.log("No .mjs files found");
+  process.exit(0);
+}
+
+let failed = 0;
+for (const file of files) {
+  const rel = relative(ROOT, file).split(sep).join("/");
+  try {
+    execFileSync(process.execPath, ["--check", file], { stdio: "pipe" });
+    console.log(`OK: ${rel}`);
+  } catch (err) {
+    failed++;
+    console.error(`FAIL: ${rel}`);
+    const stderr = err.stderr?.toString() || err.message;
+    for (const line of stderr.split("\n").filter(Boolean)) {
+      console.error(`  ${line}`);
+    }
+  }
+}
+
+if (failed) {
+  console.error(`\n${failed} of ${files.length} file(s) failed syntax check`);
+  process.exit(1);
+}
+console.log(`\nAll ${files.length} .mjs file(s) passed syntax check`);