Add smart-case support

Fixes #17

Author: sindresorhus

cli.js

@@ -12,6 +12,8 @@ const cli = meow(`
 	  --verbose -v                       Show process arguments
 	  --silent -s                        Silently kill and always exit with code 0
 	  --force-after-timeout <N>, -t <N>  Force kill processes which didn't exit after N seconds
+	  --smart-case                       Case-insensitive unless pattern contains uppercase
+	  --case-sensitive                   Force case-sensitive matching
 
 	Examples
 	  $ fkill 1337
@@ -26,7 +28,7 @@ const cli = meow(`
 	In interactive mode, 🚦n% indicates high CPU usage and 🐏n% indicates high memory usage.
 	Supports fuzzy search in the interactive mode.
 
-	The process name is case insensitive.
+	The process name is case-insensitive by default.
 `, {
 	importMeta: import.meta,
 	inferType: true,
@@ -47,15 +49,39 @@ const cli = meow(`
 			type: 'number',
 			shortFlag: 't',
 		},
+		smartCase: {
+			type: 'boolean',
+		},
+		caseSensitive: {
+			type: 'boolean',
+		},
 	},
 });
 
+const shouldIgnoreCase = (inputs, flags) => {
+	// Explicit case-sensitive flag takes precedence over smart-case
+	if (flags.caseSensitive) {
+		return false;
+	}
+
+	// Smart-case: ignore case unless ANY input contains uppercase
+	// Note: With multiple inputs, if ANY has uppercase, ALL are matched case-sensitively
+	if (flags.smartCase) {
+		const hasUpperCase = inputs.some(input => /[A-Z]/.test(String(input)));
+		return !hasUpperCase;
+	}
+
+	// Default: always ignore case (maintains backward compatibility)
+	return true;
+};
+
 if (cli.input.length === 0) {
 	const interactiveInterface = await import('./interactive.js');
 	interactiveInterface.init(cli.flags);
 } else {
 	const forceAfterTimeout = cli.flags.forceAfterTimeout === undefined ? undefined : cli.flags.forceAfterTimeout * 1000;
-	const promise = fkill(cli.input, {...cli.flags, forceAfterTimeout, ignoreCase: true});
+	const ignoreCase = shouldIgnoreCase(cli.input, cli.flags);
+	const promise = fkill(cli.input, {...cli.flags, forceAfterTimeout, ignoreCase});
 
 	if (!cli.flags.force) {
 		try {
@@ -68,7 +94,7 @@ if (cli.input.length === 0) {
 				}
 
 				const interactiveInterface = await import('./interactive.js');
-				interactiveInterface.handleFkillError(cli.input);
+				interactiveInterface.handleFkillError(cli.input, cli.flags);
 			}
 		}
 	}

interactive.js

@@ -121,32 +121,37 @@ const searchProcessesByPort = (processes, port) => processes.filter(process_ =>
 
 const searchProcessByPid = (processes, pid) => processes.find(process_ => String(process_.pid) === pid);
 
-const searchProcessesByName = (processes, term, searcher) => {
-	const lowerTerm = term.toLowerCase();
+const searchProcessesByName = (processes, term, searcher, flags = {}) => {
+	// Determine if we should match case-sensitively
+	const hasUpperCase = /[A-Z]/.test(term);
+	const shouldMatchCase = flags.caseSensitive || (flags.smartCase && hasUpperCase);
+
+	const normalizedTerm = shouldMatchCase ? term : term.toLowerCase();
 	const exactMatches = [];
 	const startsWithMatches = [];
 	const containsMatches = [];
 
 	for (const process_ of processes) {
-		const lowerName = process_.name.toLowerCase();
-		if (lowerName === lowerTerm) {
+		const normalizedName = shouldMatchCase ? process_.name : process_.name.toLowerCase();
+		if (normalizedName === normalizedTerm) {
 			exactMatches.push(process_);
-		} else if (lowerName.startsWith(lowerTerm)) {
+		} else if (normalizedName.startsWith(normalizedTerm)) {
 			startsWithMatches.push(process_);
-		} else if (lowerName.includes(lowerTerm)) {
+		} else if (normalizedName.includes(normalizedTerm)) {
 			containsMatches.push(process_);
 		}
 	}
 
 	// Fuzzy matches (excluding all exact/starts/contains matches)
+	// Keep fuzzy search case-insensitive for better UX
 	const matchedPids = new Set([...exactMatches, ...startsWithMatches, ...containsMatches].map(process_ => process_.pid));
 	const fuzzyResults = searcher.search(term).filter(process_ => !matchedPids.has(process_.pid));
 
 	// Combine in priority order
 	return [...exactMatches, ...startsWithMatches, ...containsMatches, ...fuzzyResults];
 };
 
-const filterAndSortProcesses = (processes, term, searcher) => {
+const filterAndSortProcesses = (processes, term, searcher, flags) => {
 	const filtered = processes.filter(process_ => !isHelperProcess(process_));
 
 	// No search term: show all sorted by performance
@@ -167,16 +172,21 @@ const filterAndSortProcesses = (processes, term, searcher) => {
 	}
 
 	// Search by name
-	return searchProcessesByName(filtered, term, searcher);
+	return searchProcessesByName(filtered, term, searcher, flags);
 };
 
-const handleFkillError = async processes => {
-	const shouldForceKill = await promptForceKill(processes, 'Error killing process.');
+const handleFkillError = async (inputs, flags = {}) => {
+	const shouldForceKill = await promptForceKill(inputs, 'Error killing process.');
 
 	if (shouldForceKill) {
-		await fkill(processes, {
+		// Determine case sensitivity based on flags and inputs
+		// If ANY input has uppercase letter, match case-sensitively with --smart-case
+		const hasUpperCase = inputs.some(input => /[A-Z]/.test(String(input)));
+		const ignoreCase = flags.caseSensitive ? false : (flags.smartCase ? !hasUpperCase : true);
+
+		await fkill(inputs, {
 			force: true,
-			ignoreCase: true,
+			ignoreCase,
 		});
 	}
 };
@@ -250,7 +260,7 @@ const listProcesses = async (processes, flags) => {
 		message: 'Running processes:',
 		pageSize: 10,
 		async source(term = '') {
-			const matchingProcesses = filterAndSortProcesses(processes, term, searcher);
+			const matchingProcesses = filterAndSortProcesses(processes, term, searcher, flags);
 			return matchingProcesses.map(process_ => renderProcessForDisplay(process_, flags, memoryThreshold, cpuThreshold));
 		},
 	});

readme.md

@@ -29,6 +29,8 @@ $ fkill --help
 		--verbose, -v                Show process arguments
 		--silent, -s                 Silently kill and always exit with code 0
 		--force-timeout <N>, -t <N>  Force kill processes which didn't exit after N seconds
+		--smart-case                 Case-insensitive unless pattern contains uppercase
+		--case-sensitive             Force case-sensitive matching
 
 	Examples
 		$ fkill 1337
@@ -43,7 +45,7 @@ $ fkill --help
 	In interactive mode, 🚦n% indicates high CPU usage and 🐏n% indicates high memory usage.
 	Supports fuzzy search in the interactive mode.
 
-	The process name is case insensitive.
+	The process name is case-insensitive by default.
 ```
 
 ## Interactive UI

test.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import childProcess from 'node:child_process';
 import test from 'ava';
 import {execa} from 'execa';
@@ -55,3 +56,44 @@ test('silently force killing process at unused port exits with code 0', async t
 	const {exitCode} = await execa('./cli.js', ['--force', '--silent', ':1337']);
 	t.is(exitCode, 0);
 });
+
+// Case-sensitivity tests only work on Unix-like systems
+// Windows process names work differently and don't support custom titles via noopProcess
+if (process.platform !== 'win32') {
+	test('default case-insensitive behavior', async t => {
+		const pid = await noopProcess({title: 'DefaultCase'});
+		await execa('./cli.js', ['--force', 'defaultcase']);
+		await noopProcessKilled(t, pid);
+	});
+
+	test('case-sensitive flag makes matching case-sensitive', async t => {
+		const pid = await noopProcess({title: 'CaseSensitive'});
+		await t.throwsAsync(
+			execa('./cli.js', ['--case-sensitive', '--force', 'casesensitive']),
+			{message: /Killing process casesensitive failed/},
+		);
+		// Clean up the process
+		await execa('./cli.js', ['--force', pid]);
+	});
+
+	test('smart-case with lowercase is case-insensitive', async t => {
+		const pid = await noopProcess({title: 'SmartLower'});
+		await execa('./cli.js', ['--smart-case', '--force', 'smartlower']);
+		await noopProcessKilled(t, pid);
+	});
+
+	test('smart-case with uppercase is case-sensitive', async t => {
+		const pid = await noopProcess({title: 'smartupper'});
+		await t.throwsAsync(
+			execa('./cli.js', ['--smart-case', '--force', 'SmartUpper']),
+			{message: /Killing process SmartUpper failed/},
+		);
+		// Clean up the process
+		await execa('./cli.js', ['--force', pid]);
+	});
+}
+
+test('silent flag with -s shortflag works', async t => {
+	const {exitCode} = await execa('./cli.js', ['-s', '--force', ':1337']);
+	t.is(exitCode, 0);
+});