@dizzlkheinz/ynab-mcpb 0.18.3 → 0.19.0

package/scripts/create-pr-description.js

@@ -4,148 +4,195 @@
  * Usage: node scripts/create-pr-description.js [options]
  */
 
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // Read the PR template
-const templatePath = path.join(__dirname, '..', '.github', 'pull_request_template.md');
-const template = fs.readFileSync(templatePath, 'utf-8');
+const templatePath = path.join(
+	__dirname,
+	"..",
+	".github",
+	"pull_request_template.md",
+);
+const template = fs.readFileSync(templatePath, "utf-8");
 
 // Function to detect the repository's default branch
 function getDefaultBranch() {
-  try {
-    // Try to get the default branch from origin/HEAD
-    const defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
-      encoding: 'utf-8',
-    })
-      .trim()
-      .replace('refs/remotes/origin/', '');
-    return defaultBranch;
-  } catch (err) {
-    // Fallback: try common branch names
-    try {
-      execSync('git rev-parse --verify origin/main', { encoding: 'utf-8', stdio: 'ignore' });
-      return 'main';
-    } catch {
-      try {
-        execSync('git rev-parse --verify origin/master', { encoding: 'utf-8', stdio: 'ignore' });
-        return 'master';
-      } catch {
-        console.warn('Could not detect default branch, using "main" as fallback');
-        return 'main';
-      }
-    }
-  }
+	try {
+		// Try to get the default branch from origin/HEAD
+		const defaultBranch = execSync(
+			"git symbolic-ref refs/remotes/origin/HEAD",
+			{
+				encoding: "utf-8",
+			},
+		)
+			.trim()
+			.replace("refs/remotes/origin/", "");
+		return defaultBranch;
+	} catch (err) {
+		// Fallback: try common branch names
+		try {
+			execSync("git rev-parse --verify origin/main", {
+				encoding: "utf-8",
+				stdio: "ignore",
+			});
+			return "main";
+		} catch {
+			try {
+				execSync("git rev-parse --verify origin/master", {
+					encoding: "utf-8",
+					stdio: "ignore",
+				});
+				return "master";
+			} catch {
+				console.warn(
+					'Could not detect default branch, using "main" as fallback',
+				);
+				return "main";
+			}
+		}
+	}
 }
 
 // Read package.json for version info
 const packageJson = JSON.parse(
-  fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'),
+	fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"),
 );
 
 // Read CHANGELOG.md if it exists
-let changelogEntries = '';
+let changelogEntries = "";
 try {
-  const changelog = fs.readFileSync(path.join(__dirname, '..', 'CHANGELOG.md'), 'utf-8');
-  // Extract the latest version entries
-  const latestSection = changelog.split('##')[1];
-  changelogEntries = latestSection ? `## Latest Changes\n\n${latestSection}` : '';
+	const changelog = fs.readFileSync(
+		path.join(__dirname, "..", "CHANGELOG.md"),
+		"utf-8",
+	);
+	// Extract the latest version entries
+	const latestSection = changelog.split("##")[1];
+	changelogEntries = latestSection
+		? `## Latest Changes\n\n${latestSection}`
+		: "";
 } catch (err) {
-  // No changelog
+	// No changelog
 }
 
 // Detect the default branch
 const defaultBranch = getDefaultBranch();
 
 // Get git info
-let commitMessages = '';
+let commitMessages = "";
 try {
-  const branch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-
-  // Get commit messages since branching from default branch
-  const commits = execSync(`git log ${defaultBranch}..${branch} --pretty=format:"- %s"`, {
-    encoding: 'utf-8',
-  }).trim();
-
-  if (commits) {
-    commitMessages = `## Commits\n\n${commits}\n\n`;
-  }
+	const branch = execSync("git branch --show-current", {
+		encoding: "utf-8",
+	}).trim();
+
+	// Get commit messages since branching from default branch
+	const commits = execSync(
+		`git log ${defaultBranch}..${branch} --pretty=format:"- %s"`,
+		{
+			encoding: "utf-8",
+		},
+	).trim();
+
+	if (commits) {
+		commitMessages = `## Commits\n\n${commits}\n\n`;
+	}
 } catch (err) {
-  console.warn('Could not get git commit info');
+	console.warn("Could not get git commit info");
 }
 
 // Get file change stats
-let changeStats = '';
+let changeStats = "";
 try {
-  const stats = execSync(`git diff --shortstat ${defaultBranch}...HEAD`, {
-    encoding: 'utf-8',
-  }).trim();
+	const stats = execSync(`git diff --shortstat ${defaultBranch}...HEAD`, {
+		encoding: "utf-8",
+	}).trim();
 
-  if (stats) {
-    changeStats = `**Changes**: ${stats}\n\n`;
-  }
+	if (stats) {
+		changeStats = `**Changes**: ${stats}\n\n`;
+	}
 } catch (err) {
-  console.warn('Could not get change stats');
+	console.warn("Could not get change stats");
 }
 
 // Get previous version from default branch
 function getPreviousVersion() {
-  try {
-    // Try to get package.json from default branch
-    const previousPackageJson = execSync(`git show origin/${defaultBranch}:package.json`, {
-      encoding: 'utf-8',
-    });
-    const previousPkg = JSON.parse(previousPackageJson);
-    return previousPkg.version;
-  } catch (err) {
-    // Fallback: try to get the latest git tag
-    try {
-      const latestTag = execSync('git describe --tags --abbrev=0', {
-        encoding: 'utf-8',
-      }).trim();
-      // Remove 'v' prefix if present
-      return latestTag.replace(/^v/, '');
-    } catch {
-      // Fallback: try to get tags sorted by version
-      try {
-        const tags = execSync('git tag --sort=-v:refname', {
-          encoding: 'utf-8',
-        }).trim();
-        const latestTag = tags.split('\n')[0];
-        if (latestTag) {
-          return latestTag.replace(/^v/, '');
-        }
-      } catch {
-        console.warn('Could not determine previous version, using current version as fallback');
-        return packageJson.version;
-      }
-    }
-  }
-  return packageJson.version;
+	try {
+		// Try to get package.json from default branch
+		const previousPackageJson = execSync(
+			`git show origin/${defaultBranch}:package.json`,
+			{
+				encoding: "utf-8",
+			},
+		);
+		const previousPkg = JSON.parse(previousPackageJson);
+		return previousPkg.version;
+	} catch (err) {
+		// Fallback: try to get the latest git tag
+		try {
+			const latestTag = execSync("git describe --tags --abbrev=0", {
+				encoding: "utf-8",
+			}).trim();
+			// Remove 'v' prefix if present
+			return latestTag.replace(/^v/, "");
+		} catch {
+			// Fallback: try to get tags sorted by version
+			try {
+				const tags = execSync("git tag --sort=-v:refname", {
+					encoding: "utf-8",
+				}).trim();
+				const latestTag = tags.split("\n")[0];
+				if (latestTag) {
+					return latestTag.replace(/^v/, "");
+				}
+			} catch {
+				console.warn(
+					"Could not determine previous version, using current version as fallback",
+				);
+				return packageJson.version;
+			}
+		}
+	}
+	return packageJson.version;
 }
 
 // Smart defaults based on branch name and commits
 function detectChangeType(branchName, commits) {
-  const name = branchName.toLowerCase();
-  const commitText = commits.toLowerCase();
-
-  if (name.includes('major') || commitText.includes('breaking') || commitText.includes('major:')) {
-    return 'Major';
-  } else if (name.includes('minor') || name.includes('feature') || name.includes('feat')) {
-    return 'Minor';
-  } else if (name.includes('patch') || name.includes('fix') || name.includes('hotfix')) {
-    return 'Patch';
-  }
-
-  return 'Unknown';
+	const name = branchName.toLowerCase();
+	const commitText = commits.toLowerCase();
+
+	if (
+		name.includes("major") ||
+		commitText.includes("breaking") ||
+		commitText.includes("major:")
+	) {
+		return "Major";
+	}
+	if (
+		name.includes("minor") ||
+		name.includes("feature") ||
+		name.includes("feat")
+	) {
+		return "Minor";
+	}
+	if (
+		name.includes("patch") ||
+		name.includes("fix") ||
+		name.includes("hotfix")
+	) {
+		return "Patch";
+	}
+
+	return "Unknown";
 }
 
-const branch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+const branch = execSync("git branch --show-current", {
+	encoding: "utf-8",
+}).trim();
 const changeType = detectChangeType(branch, commitMessages);
 
 // Build the description
@@ -153,51 +200,53 @@ let description = template;
 
 // Add summary if we have commits
 if (commitMessages) {
-  const summarySection = commitMessages.split('\n').slice(0, 5).join('\n');
-  description = description.replace(
-    'Describe the change and its motivation.',
-    `Describe the change and its motivation.\n\n${summarySection}`,
-  );
+	const summarySection = commitMessages.split("\n").slice(0, 5).join("\n");
+	description = description.replace(
+		"Describe the change and its motivation.",
+		`Describe the change and its motivation.\n\n${summarySection}`,
+	);
 }
 
 // Pre-check the type of change if we detected it
-if (changeType === 'Major') {
-  description = description.replace('- [ ] Major', '- [x] Major');
-} else if (changeType === 'Minor') {
-  description = description.replace('- [ ] Minor', '- [x] Minor');
-} else if (changeType === 'Patch') {
-  description = description.replace('- [ ] Patch', '- [x] Patch');
+if (changeType === "Major") {
+	description = description.replace("- [ ] Major", "- [x] Major");
+} else if (changeType === "Minor") {
+	description = description.replace("- [ ] Minor", "- [x] Minor");
+} else if (changeType === "Patch") {
+	description = description.replace("- [ ] Patch", "- [x] Patch");
 }
 
 // Add version info
 const currentVersion = packageJson.version;
 const previousVersion = getPreviousVersion();
 description = description.replace(
-  '`X.Y.Z` → `X.Y.Z`',
-  `\`${previousVersion}\` → \`${currentVersion}\``,
+	"`X.Y.Z` → `X.Y.Z`",
+	`\`${previousVersion}\` → \`${currentVersion}\``,
 );
 
 // Add changelog entries if available
 if (changelogEntries) {
-  description += `\n\n---\n\n${changelogEntries}`;
+	description += `\n\n---\n\n${changelogEntries}`;
 }
 
 // Add change stats if available
 if (changeStats) {
-  description += `\n\n${changeStats}`;
+	description += `\n\n${changeStats}`;
 }
 
 // Add commit history
 if (commitMessages) {
-  description += `\n${commitMessages}`;
+	description += `\n${commitMessages}`;
 }
 
 // Output the description
 console.log(description);
 
 // Optionally write to file
-const outputPath = path.join(__dirname, '..', '.pr-description.md');
+const outputPath = path.join(__dirname, "..", ".pr-description.md");
 fs.writeFileSync(outputPath, description);
 console.error(`\n✅ PR description written to: ${outputPath}`);
-console.error('\nTo create PR with this description:');
-console.error(`  gh pr create --body-file .pr-description.md --title "Your PR title"`);
+console.error("\nTo create PR with this description:");
+console.error(
+	`  gh pr create --body-file .pr-description.md --title "Your PR title"`,
+);

package/scripts/run-all-tests.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Clean test runner for all test suites
+ * Runs unit, integration, e2e, and performance tests with summarized output
+ */
+
+// Filter out DEP0190 deprecation warning for shell spawn (safe in this controlled context)
+// We use shell:true intentionally for cross-platform npm execution
+// Must remove default listeners first, then add filtered handler
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+	// Check both code and message for DEP0190 (shell spawn with args)
+	const isDep0190 =
+		warning.code === "DEP0190" ||
+		(warning.name === "DeprecationWarning" &&
+			warning.message?.includes("DEP0190"));
+	if (isDep0190) {
+		return; // Suppress only this specific warning
+	}
+	console.warn(warning);
+});
+
+import { spawn } from "node:child_process";
+
+const isFull = process.argv.includes("--full");
+
+const SUITES = [
+	{ name: "Unit", script: "test:unit" },
+	{
+		name: "Integration",
+		script: isFull ? "test:integration:full" : "test:integration:core",
+	},
+	{ name: "E2E", script: "test:e2e" },
+	{ name: "Performance", script: "test:performance" },
+];
+
+const results = [];
+let hasFailure = false;
+
+async function runSuite(suite) {
+	return new Promise((resolve) => {
+		const start = Date.now();
+		process.stdout.write(`Running ${suite.name} tests... `);
+
+		const proc = spawn("npm", ["run", suite.script], {
+			stdio: ["inherit", "pipe", "pipe"],
+			shell: true,
+			cwd: process.cwd(),
+			env: { ...process.env, FORCE_COLOR: "0" },
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		proc.stdout?.on("data", (data) => {
+			stdout += data.toString();
+		});
+
+		proc.stderr?.on("data", (data) => {
+			stderr += data.toString();
+		});
+
+		proc.on("error", (err) => {
+			console.log("\x1b[31m✗\x1b[0m (spawn error)");
+			hasFailure = true;
+			results.push({
+				name: suite.name,
+				passed: 0,
+				failed: 0,
+				skipped: 0,
+				duration: ((Date.now() - start) / 1000).toFixed(1),
+				success: false,
+				stdout: "",
+				stderr: err.message,
+			});
+			resolve();
+		});
+
+		proc.on("close", (code) => {
+			const duration = ((Date.now() - start) / 1000).toFixed(1);
+
+			// Parse results from output
+			// Vitest format: "Tests  1584 passed | 13 skipped (1597)"
+			// Also handles: "Tests  1584 passed (1584)"
+			let passed = 0;
+			let failed = 0;
+			let skipped = 0;
+
+			// Look for the Tests summary line (last occurrence)
+			const lines = stdout.split("\n");
+			for (const line of lines) {
+				// Skip "Test Files" line, we want "Tests" line
+				if (line.includes("Tests") && !line.includes("Test Files")) {
+					const passMatch = line.match(/(\d+)\s+passed/);
+					const failMatch = line.match(/(\d+)\s+failed/);
+					const skipMatch = line.match(/(\d+)\s+skipped/);
+
+					if (passMatch) passed = Number.parseInt(passMatch[1], 10);
+					if (failMatch) failed = Number.parseInt(failMatch[1], 10);
+					if (skipMatch) skipped = Number.parseInt(skipMatch[1], 10);
+				}
+			}
+
+			const success = code === 0;
+			if (!success) hasFailure = true;
+
+			const status = success ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m";
+			console.log(`${status} (${duration}s)`);
+
+			results.push({
+				name: suite.name,
+				passed,
+				failed,
+				skipped,
+				duration,
+				success,
+				stdout: success ? "" : stdout,
+				stderr: success ? "" : stderr,
+			});
+
+			resolve();
+		});
+	});
+}
+
+async function main() {
+	const title = isFull ? "Running All Tests (Full Suite)" : "Running All Tests";
+	console.log(`\n\x1b[1m━━━ ${title} ━━━\x1b[0m\n`);
+
+	for (const suite of SUITES) {
+		await runSuite(suite);
+	}
+
+	// Print summary
+	console.log("\n\x1b[1m━━━ Test Summary ━━━\x1b[0m\n");
+
+	const totalPassed = results.reduce((sum, r) => sum + r.passed, 0);
+	const totalFailed = results.reduce((sum, r) => sum + r.failed, 0);
+	const totalSkipped = results.reduce((sum, r) => sum + r.skipped, 0);
+	const totalDuration = results
+		.reduce((sum, r) => sum + Number.parseFloat(r.duration), 0)
+		.toFixed(1);
+
+	// Table header
+	console.log("Suite          Passed   Failed   Skipped   Time");
+	console.log("─".repeat(50));
+
+	for (const r of results) {
+		const status = r.success ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m";
+		const name = r.name.padEnd(12);
+		const passed = String(r.passed).padStart(6);
+		const failed =
+			r.failed > 0
+				? `\x1b[31m${String(r.failed).padStart(8)}\x1b[0m`
+				: String(r.failed).padStart(8);
+		const skipped = String(r.skipped).padStart(9);
+		const time = `${r.duration}s`.padStart(7);
+		console.log(`${status} ${name} ${passed} ${failed} ${skipped} ${time}`);
+	}
+
+	console.log("─".repeat(50));
+
+	const totalStatus = hasFailure ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
+	const totalLabel = "Total".padEnd(12);
+	const passedStr = String(totalPassed).padStart(6);
+	const failedStr =
+		totalFailed > 0
+			? `\x1b[31m${String(totalFailed).padStart(8)}\x1b[0m`
+			: String(totalFailed).padStart(8);
+	const skippedStr = String(totalSkipped).padStart(9);
+	const timeStr = `${totalDuration}s`.padStart(7);
+	console.log(
+		`${totalStatus} ${totalLabel} ${passedStr} ${failedStr} ${skippedStr} ${timeStr}`,
+	);
+
+	console.log();
+
+	// Print failures if any
+	if (hasFailure) {
+		console.log("\x1b[31m━━━ Failures ━━━\x1b[0m\n");
+		for (const r of results.filter((r) => !r.success)) {
+			console.log(`\x1b[1m${r.name}:\x1b[0m`);
+			if (r.stdout) {
+				// Show last 3000 chars of stdout to capture test failures without overwhelming output
+				const trimmedStdout =
+					r.stdout.length > 3000 ? `...${r.stdout.slice(-3000)}` : r.stdout;
+				console.log("\x1b[2mOutput:\x1b[0m");
+				console.log(trimmedStdout);
+			}
+			if (r.stderr) {
+				console.log("\x1b[2mErrors:\x1b[0m");
+				console.log(r.stderr);
+			}
+			console.log();
+		}
+		process.exit(1);
+	}
+
+	console.log("\x1b[32mAll tests passed!\x1b[0m\n");
+}
+
+main().catch((err) => {
+	console.error("Test runner error:", err);
+	process.exit(1);
+});

package/scripts/run-domain-integration-tests.js

@@ -2,35 +2,45 @@
 /**
  * Runs domain-scoped integration tests with tier filtering.
  */
-import { spawn } from 'node:child_process';
+import { spawn } from "node:child_process";
 
 const rawArgs = process.argv.slice(2);
-const separatorIndex = rawArgs.indexOf('--');
-const domainArgs = separatorIndex === -1 ? rawArgs : rawArgs.slice(0, separatorIndex);
-const passthroughArgs = separatorIndex === -1 ? [] : rawArgs.slice(separatorIndex + 1);
+const separatorIndex = rawArgs.indexOf("--");
+const domainArgs =
+	separatorIndex === -1 ? rawArgs : rawArgs.slice(0, separatorIndex);
+const passthroughArgs =
+	separatorIndex === -1 ? [] : rawArgs.slice(separatorIndex + 1);
 
 if (domainArgs.length === 0) {
-  console.error('Usage: node scripts/run-domain-integration-tests.js <domain> [domain ...]');
-  process.exit(1);
+	console.error(
+		"Usage: node scripts/run-domain-integration-tests.js <domain> [domain ...]",
+	);
+	process.exit(1);
 }
 
-const domains = domainArgs.join(',');
+const domains = domainArgs.join(",");
 const env = {
-  ...process.env,
-  INTEGRATION_TEST_TIER: 'domain',
-  INTEGRATION_TEST_DOMAINS: domains,
+	...process.env,
+	INTEGRATION_TEST_TIER: "domain",
+	INTEGRATION_TEST_DOMAINS: domains,
 };
 
-const vitestArgs = ['vitest', 'run', '--project', 'integration:domain', ...passthroughArgs];
-const runner = 'npx';
-const useShell = process.platform === 'win32';
+const vitestArgs = [
+	"vitest",
+	"run",
+	"--project",
+	"integration:domain",
+	...passthroughArgs,
+];
+const runner = "npx";
+const useShell = process.platform === "win32";
 
 const child = spawn(runner, vitestArgs, {
-  stdio: 'inherit',
-  env,
-  shell: useShell,
+	stdio: "inherit",
+	env,
+	shell: useShell,
 });
 
-child.on('close', (code) => {
-  process.exit(code ?? 1);
+child.on("close", (code) => {
+	process.exit(code ?? 1);
 });