@theholocron/cli 1.0.0

package/src/tasks/find/find-project.example.ts

@@ -0,0 +1,23 @@
+import { HOME } from "@/const";
+import { find } from "@/tasks";
+
+async function main() {
+	const [, , folder] = process.argv;
+
+	try {
+		const [err, data] = await find(folder, HOME, {});
+
+		if (err) {
+			console.error(err);
+			process.exit(1);
+		}
+
+		console.log("Folders Found:\n");
+		console.table(data);
+	} catch (error) {
+		console.error("An error occurred:", error);
+		process.exit(1);
+	}
+}
+
+main();

package/src/tasks/find/find-project.ts

@@ -0,0 +1,76 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { type CLIOptions } from "@/cli";
+import { HOME, SYSTEM_IGNORED_FOLDERS, type IgnoredFolders } from "@/const";
+import { type Return } from "@/types";
+import { $, config, log } from "@/utils";
+
+export type Project = Record<string, string>;
+export interface FindProjectsOpts extends CLIOptions {
+	maxSearchDepth?: number;
+}
+
+const FN = "find.projects";
+
+/**
+ * Searches directory for any Node.js project (by detecting package.json), ignoring hidden directories.
+ *
+ * @param {string} [location] - Directory path to search within.
+ * @param {FindProjectsOpts} [options] - Additional options for customization.
+ * @returns {Promise<Return<Project[]>>} An error or an array of locations with all of the file paths found.
+ */
+export async function findProjects(location?: string, options: FindProjectsOpts = {}): Promise<Return<Project[]>> {
+	log.data(FN, "arguments", { location, ...options }, options);
+	const start = performance.now();
+	const maxDepth: number = options?.maxSearchDepth || 5;
+	const results: Project[] = [];
+	const loc: string = location || HOME;
+
+	async function searchDirectory(cwd: string, depth: number = 0): Promise<void> {
+		log.process(FN, `searching in ${cwd}`, options);
+		let files: string[];
+		try {
+			files = await fs.readdir(cwd);
+		} catch {
+			return;
+		}
+
+		log.data(FN, "files", files, options);
+		for (const file of files) {
+			if (
+				file.startsWith(".") ||
+				SYSTEM_IGNORED_FOLDERS.includes(file as IgnoredFolders) ||
+				config.get("preferences.ignoredFolders").includes(file)
+			) {
+				continue; // skip all of these files, folders
+			}
+
+			const filePath = path.join(cwd, file);
+			log.process(FN, `checking if ${filePath} is a directory`, options);
+			const [, dir] = await $.directory(filePath);
+			// if there are no files in it, its not a folder i care about
+			if (!dir?.files.length || !dir?.path) {
+				continue;
+			}
+
+			log.data(FN, "isValidDirectory", dir?.path ?? "", options);
+
+			if (dir.files.includes(path.join(dir.path, "package.json"))) {
+				// Node.js project detected
+				const pkg = await fs.readFile(path.join(dir.path, "package.json"), "utf-8");
+				const packageData = JSON.parse(pkg);
+				results.push({
+					name: packageData.name,
+					value: dir.path,
+				});
+			} else if (maxDepth === -1 || depth < maxDepth) {
+				await searchDirectory(filePath, depth + 1);
+			}
+		}
+	}
+
+	await searchDirectory(loc);
+
+	const end = performance.now();
+	return [null, results, end - start];
+}

package/src/tasks/find/index.ts

@@ -0,0 +1 @@
+export * from "./find-project";

package/src/tasks/index.ts

@@ -0,0 +1,2 @@
+export * from "./find";
+export * from "./replace";

package/src/tasks/replace/README.md

@@ -0,0 +1,61 @@
+# Find & Replace
+
+Find a string in a file and replace it with something else.
+
+## Usage
+
+```javascript
+import { findReplace } from "@/tasks";
+
+const filePaths = [
+	`/packages/developer-experience/sdk-session/src/tests/handlers.ts`,
+];
+const baseString: string = "const BAM_BROWSER_SDK_VERSION =";
+
+async function main() {
+	const [, , version] = process.argv;
+	const [major, minor] = version.split(".");
+
+	try {
+		const [err, data, duration] = await findReplace(filePaths, baseString, `${major}.${minor}`);
+
+		if (err) {
+			console.error("Error:", err);
+			process.exit(1);
+		}
+
+		console.log("Files replaced:\n");
+		console.table(data);
+		console.log(`It took ${duration} milliseconds`);
+	}
+	catch (error) {
+		console.error("Error:", error);
+	}
+}
+
+main();
+```
+
+## API
+
+### `findReplace(filePaths: string[], searchTerm: string, replacement: string)`
+
+Returns an array of file paths that were modified.
+
+#### filePaths
+
+The file paths with which to search.
+
+Type: `string[]`
+
+#### searchTerm
+
+The search term to look for and replace.
+
+Type: `string`
+
+#### replacement
+
+A string to replace with
+
+Type: `string`

package/src/tasks/replace/index.ts

@@ -0,0 +1 @@
+export * from "./replace";

package/src/tasks/replace/replace.example.ts

@@ -0,0 +1,31 @@
+import { HOME } from "@/const";
+import { find } from "@/tasks";
+
+const filePaths = [
+	`${HOME}/Code/disney/solo/apps/commerce/src/common/context/__browser-mocks__/handlers.ts`,
+	`${HOME}/Code/disney/solo/packages/developer-experience/sdk-session/src/tests/handlers.ts`,
+	`${HOME}/Code/disney/solo/packages/instrumentation/src/glimpse/hooks/use-fire-fed-purchase-event.test.tsx`,
+];
+const baseString: string = "const BAM_BROWSER_SDK_VERSION =";
+
+async function main() {
+	const [, , version] = process.argv;
+	const [major, minor] = version.split(".");
+
+	try {
+		const [err, data, duration] = await find.replace(filePaths, baseString, `${major}.${minor}`);
+
+		if (err) {
+			console.error("Error:", err);
+			process.exit(1);
+		}
+
+		console.log("Files replaced:\n");
+		console.table(data);
+		console.log(`It took ${duration} milliseconds`);
+	} catch (error) {
+		console.error("Error:", error);
+	}
+}
+
+main();

package/src/tasks/replace/replace.ts

@@ -0,0 +1,95 @@
+import { type CLIOptions } from "@/cli";
+import { type Return } from "@/types";
+import { $, log } from "@/utils";
+
+const FN = "find.replace";
+
+/**
+ * Perform a case-sensitive replacement in a string, keeping the casing format of each found instance.
+ *
+ * @param {string} text - The text in which to perform the replacement.
+ * @param {string} searchTerm - The term to search for, ignoring case.
+ * @param {string} replacement - The replacement term.
+ * @returns {string} - The updated text with replacements made.
+ */
+function replaceWithRespectToCase(text: string, searchTerm: string, replacement: string): string {
+	// Create a regex to match search term with flexible spacing/hyphens between words
+	const words = searchTerm.split(/[- ]/).map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")); // Escape special chars
+	const regex = new RegExp(words.join("[- ]?"), "gi"); // Allow for spaces or hyphens between words
+
+	return text.replace(regex, (match) => {
+		// Transform replacement to match the case of the original found match
+		const replacementWords = replacement.split(/[- ]/);
+		const transformed = match
+			.split(/[- ]/)
+			.map((word, index) => {
+				const replacementWord = replacementWords[index] || ""; // Handle possible extra words in replacement
+				return /[A-Z]/.test(word[0])
+					? replacementWord.charAt(0).toUpperCase() + replacementWord.slice(1)
+					: replacementWord.toLowerCase();
+			})
+			.join(" ");
+
+		return transformed.trim();
+	});
+}
+
+/**
+ * Update a specific string in multiple files.
+ *
+ * @param {string[]} filePaths - An array of file paths to be updated.
+ * @param {string} searchTerm - The base string to match.
+ * @param {string} replacement - The new string to replace with.
+ * @param {CLIOptions} [options={}] - CLI options for logging and additional processing.
+ * @returns {Promise<Return<string[]>>} - A promise that resolves to a tuple containing an error (if any), an object with the update status for each domain, and the time taken.
+ */
+export async function findReplace(
+	filePaths: string[],
+	searchTerm: string,
+	replacement: string,
+	options: CLIOptions = {}
+): Promise<Return<string[]>> {
+	if (!filePaths || !Array.isArray(filePaths)) {
+		return [new Error("No file paths were provided!"), null, 0];
+	}
+
+	if (!searchTerm) {
+		return [new Error("No search term was provided!"), null, 0];
+	}
+
+	if (!replacement) {
+		return [new Error("No replacement was provided!"), null, 0];
+	}
+
+	const start = performance.now();
+	const output: string[] = [];
+
+	for (const filePath of filePaths) {
+		log.process(FN, `Searching ${filePath} for occurrences of "${searchTerm}"`, options);
+
+		try {
+			// Read the file content
+			const [fileErr, file] = await $.file(filePath);
+			if (fileErr || !file?.content) {
+				log.info(FN, `Cannot read file ${filePath}: skipping`, options);
+				continue;
+			}
+
+			// Perform the replacement
+			const updatedData = replaceWithRespectToCase(file.content, searchTerm, replacement);
+
+			// Write back only if the content changed
+			if (updatedData !== file.content) {
+				await $.file(filePath, updatedData, true); // Ensure this function overwrites the file content
+				output.push(filePath);
+				log.process(FN, `Updated ${filePath}`, options);
+			} else {
+				log.process(FN, `No changes in ${filePath}`, options);
+			}
+		} catch (error) {
+			log.error(FN, `Error processing file ${filePath}: ${(error as Error).message}`, options);
+		}
+	}
+
+	return [null, output, performance.now() - start];
+}

package/src/ui/README.md

@@ -0,0 +1,8 @@
+# UI
+
+A set of functions designed to be used as a UI for interacting with the client.
+
+## What's Available
+
+* [open](./open/README.md) - open an app in your `$EDITOR`
+* [prompts](./prompts/README.md) - prompt the user with various UI tools

package/src/ui/index.ts

@@ -0,0 +1,2 @@
+export { open } from "./open";
+export { prompt, type Choice } from "./prompts";

package/src/ui/open/README.md

@@ -0,0 +1,58 @@
+# Open an Application
+
+Open an application after a confirmation.
+
+## Usage
+
+```javascript
+import { open } from "@/ui";
+
+async function main () {
+	const [, , name, location] = process.argv;
+
+	try {
+		const [err, isOpened] = await open.editor(name, location);
+
+		if (err) {
+			console.error(err);
+			process.exit(1);
+		}
+
+		console.log(`${name} ${isOpened ? "was" : "was not"} opened.`);
+	}
+	catch (error) {
+		console.error('An error occurred:', error);
+		process.exit(1);
+	}
+}
+
+main();
+```
+
+## API
+
+### `editor(name: string, location: string)`
+
+Returns a Promise that resolves to a boolean.
+
+#### name
+
+A name of the application.
+
+Type: `string`
+
+#### location
+
+A path of where the application is located.
+
+Type: `string`
+
+### `browser(url: string)`
+
+Opens the URL in the users default browser.
+
+#### url
+
+The URL to open.
+
+Type: `string`

package/src/ui/open/index.ts

@@ -0,0 +1,7 @@
+import { openBrowser } from "./open-browser";
+import { openApp } from "./open-editor";
+
+export const open = {
+	browser: openBrowser,
+	editor: openApp,
+};

package/src/ui/open/open-browser.ts

@@ -0,0 +1,25 @@
+import defaultBrowser from "default-browser";
+import open, { apps } from "open";
+
+/**
+ * Opens an application if the user confirms.
+ *
+ * @param {string} name - The name of the application.
+ * @returns {Promise<void>} - A promise that resolves to a tuple containing an error (if any), a boolean indicating if the app was opened, and the time taken to perform the operation.
+ */
+export async function openBrowser(url: string): Promise<void> {
+	if (!url) {
+		throw new Error("No URL was provided!");
+	}
+
+	let browser = apps.browser;
+	const { name } = await defaultBrowser();
+	const supported = ["chrome", "firefox", "edge"];
+	if (!supported.includes(name.toLowerCase())) {
+		browser = apps.chrome;
+	}
+
+	await open(url, {
+		app: { name: browser },
+	});
+}

package/src/ui/open/open-editor.example.ts

@@ -0,0 +1,14 @@
+import { open } from "@/ui";
+
+async function main() {
+	const [, , name, location] = process.argv;
+
+	try {
+		await open.editor(name, location);
+	} catch (error) {
+		console.error("An error occurred:", error);
+		process.exit(1);
+	}
+}
+
+main();

package/src/ui/open/open-editor.ts

@@ -0,0 +1,30 @@
+import openEditor from "open-editor";
+import { prompt } from "@/ui";
+
+/**
+ * Opens an application if the user confirms.
+ *
+ * @param {string} name - The name of the application.
+ * @param {string} location - The file location of the application.
+ * @returns {Promise<void>}
+ */
+export async function openApp(location: string, name?: string, bypass: boolean = false): Promise<void> {
+	if (!location) {
+		throw new Error("No app location was provided!");
+	}
+	const open = async () =>
+		await openEditor(
+			[
+				{
+					file: location,
+				},
+			],
+			{ wait: true }
+		);
+
+	if (!bypass) {
+		await prompt.confirm(`Do you want to open ${name}?`, open);
+	} else {
+		open();
+	}
+}

package/src/ui/prompts/README.md

@@ -0,0 +1,36 @@
+# Prompts
+
+Inquirer prompts
+
+## Usage
+
+```javascript
+import { prompt } from "@/ui";
+
+async function main() {
+	const [, , project] = process.argv;
+
+	try {
+		const filepath = await prompt.search(project, undefined, undefined, {});
+		console.log(filepath);
+	}
+	catch (error) {
+		console.error("Error:", error);
+	}
+}
+
+main();
+```
+
+## API
+
+### `project(message?: string)`
+
+Returns a string of the directory selected.
+
+#### message
+
+The message to display to the user.
+
+Type: `string`
+Default: "Enter a project:"

package/src/ui/prompts/autocomplete.prompt.ts

@@ -0,0 +1,18 @@
+import autocomplete from "inquirer-autocomplete-standalone";
+import { type Choice } from "./types";
+
+export async function autocompletePrompt(source: Choice<string>[], msg?: string): Promise<string> {
+	return await autocomplete({
+		emptyText: "No results found. Please enter a term",
+		message: msg || "Search a term",
+		source: async (input?: string) =>
+			source.filter(({ name }) => {
+				const proj = name?.toLowerCase() ?? "";
+				if (proj.length > 0) {
+					return proj.includes(input?.toLowerCase() ?? "");
+				}
+
+				return "";
+			}),
+	});
+}

package/src/ui/prompts/confirm.prompt.ts

@@ -0,0 +1,21 @@
+import { confirm } from "@inquirer/prompts";
+
+type Callback = () => void | Promise<void>;
+
+export async function confirmPrompt(
+	message: string,
+	callback: Callback,
+	error: Callback = () => {
+		/* noOp */
+	}
+): Promise<void> {
+	const should = await confirm({
+		message,
+	});
+
+	if (should) {
+		await callback();
+	} else {
+		await error();
+	}
+}

package/src/ui/prompts/index.ts

@@ -0,0 +1,17 @@
+import { autocompletePrompt } from "./autocomplete.prompt";
+import { confirmPrompt } from "./confirm.prompt";
+import { inputPrompt } from "./input.prompt";
+import { searchPrompt } from "./search.prompt";
+import { selectPrompt } from "./select.prompt";
+import { validate } from "./utils";
+
+export * from "./types";
+
+export const prompt = {
+	autocomplete: autocompletePrompt,
+	confirm: confirmPrompt,
+	input: inputPrompt,
+	search: searchPrompt,
+	select: selectPrompt,
+	validate,
+};

package/src/ui/prompts/input.prompt.ts

@@ -0,0 +1,15 @@
+import { input } from "@inquirer/prompts";
+import { validate } from "./utils";
+
+export async function inputPrompt(message: string, isRequired?: boolean = false, options): Promise<string> {
+	const opts = {
+		message,
+		...options,
+	};
+
+	if (isRequired) {
+		opts.validate = validate.isNotEmpty;
+	}
+
+	return await input(opts);
+}

package/src/ui/prompts/search.prompt.ts

@@ -0,0 +1,33 @@
+import autocomplete from "inquirer-autocomplete-standalone";
+import { type CLIOptions } from "@/cli";
+import { findProjects } from "@/tasks";
+import { $, getDirectoryByLevel } from "@/utils";
+
+export async function searchPrompt(location?: string, msg?: string, options: CLIOptions): Promise<string> {
+	const message = msg || "Choose a project:";
+
+	const dirname: string = await autocomplete({
+		emptyText: "No results found. Please enter the location",
+		message,
+		pageSize: 10,
+		source: async (input?: string) => {
+			const term = input?.toLowerCase() ?? "";
+			const [, results] = await findProjects(location, options);
+			const filtered = results
+				.map(({ name, value }) => ({ name: `${name} (${getDirectoryByLevel(value)})`, value }))
+				.filter(({ name }) => {
+					const proj = name?.toLowerCase() ?? "";
+					if (proj.length > 0) {
+						return proj.includes(term);
+					}
+
+					return "";
+				});
+
+			return filtered;
+		},
+	});
+
+	const [, dir] = await $.directory(dirname);
+	return dir?.path ?? "";
+}

package/src/ui/prompts/select.prompt.ts

@@ -0,0 +1,17 @@
+import { checkbox } from "@inquirer/prompts";
+import { type Choice } from "./types";
+
+export async function selectPrompt(
+	selected: string[] | null,
+	message: string,
+	choices: Choice<string>[]
+): Promise<string[]> {
+	if (selected) {
+		return selected;
+	}
+
+	return await checkbox({
+		message,
+		choices,
+	});
+}

package/src/ui/prompts/types.ts

@@ -0,0 +1,8 @@
+export type Choice<Value> = {
+	description?: string;
+	disabled?: boolean | string;
+	checked?: boolean;
+	name?: string;
+	type?: never;
+	value: Value;
+};

package/src/ui/prompts/utils.ts

@@ -0,0 +1,11 @@
+function isNotEmpty(val: string): boolean | string {
+	if (!val || val.trim().length === 0) {
+		return "Cannot be empty";
+	}
+
+	return true;
+}
+
+export const validate = {
+	isNotEmpty,
+};