jsrepo 1.0.0

package/src/commands/diff.ts

@@ -0,0 +1,218 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cancel, confirm, isCancel, outro, spinner } from '@clack/prompts';
+import color from 'chalk';
+import { Command, program } from 'commander';
+import { diffLines } from 'diff';
+import * as v from 'valibot';
+import { context } from '..';
+import { getConfig } from '../config';
+import { OUTPUT_FILE } from '../utils';
+import { type Block, isTestFile } from '../utils/build';
+import { formatDiff } from '../utils/diff';
+import { getInstalledBlocks } from '../utils/get-installed-blocks';
+import { getWatermark } from '../utils/get-watermark';
+import * as gitProviders from '../utils/git-providers';
+import { languages } from '../utils/language-support';
+import { intro } from '../utils/prompts';
+
+const L = color.gray('│');
+
+const schema = v.object({
+	allow: v.boolean(),
+	expand: v.boolean(),
+	maxUnchanged: v.number(),
+	repo: v.optional(v.string()),
+});
+
+type Options = v.InferInput<typeof schema>;
+
+const diff = new Command('diff')
+	.description('Compares local blocks to the blocks in the provided repository.')
+	.option('-A, --allow', 'Allow jsrepo to download code from the provided repo.', false)
+	.option('-E, --expand', 'Expands the diff so you see everything.', false)
+	.option('--repo <repo>', 'Repository to download the blocks from.')
+	.option(
+		'--max-unchanged <number>',
+		'Maximum unchanged lines that will show without being collapsed.',
+		(val) => Number.parseInt(val), // this is such a dumb api thing
+		3
+	)
+	.action(async (opts) => {
+		const options = v.parse(schema, opts);
+
+		await _diff(options);
+	});
+
+type RemoteBlock = Block & { sourceRepo: gitProviders.Info };
+
+const _diff = async (options: Options) => {
+	intro(context.package.version);
+
+	const loading = spinner();
+
+	const config = getConfig().match(
+		(val) => val,
+		(err) => program.error(color.red(err))
+	);
+
+	const blocksMap: Map<string, RemoteBlock> = new Map();
+
+	let repoPaths = config.repos;
+
+	// we just want to override all others if supplied via the CLI
+	if (options.repo) repoPaths = [options.repo];
+
+	if (!options.allow && options.repo) {
+		const result = await confirm({
+			message: `Allow ${color.cyan('jsrepo')} to download and run code from ${color.cyan(options.repo)}?`,
+			initialValue: true,
+		});
+
+		if (isCancel(result) || !result) {
+			cancel('Canceled!');
+			process.exit(0);
+		}
+	}
+
+	loading.start(`Fetching blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	for (const repo of repoPaths) {
+		const providerInfo: gitProviders.Info = (await gitProviders.getProviderInfo(repo)).match(
+			(info) => info,
+			(err) => program.error(color.red(err))
+		);
+
+		const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+
+		const categories = (await gitProviders.getManifest(manifestUrl)).match(
+			(val) => val,
+			(err) => program.error(color.red(err))
+		);
+
+		for (const category of categories) {
+			for (const block of category.blocks) {
+				blocksMap.set(
+					`${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+					{
+						...block,
+						sourceRepo: providerInfo,
+					}
+				);
+			}
+		}
+	}
+
+	loading.stop(`Retrieved blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	const installedBlocks = getInstalledBlocks(blocksMap, config);
+
+	for (const blockSpecifier of installedBlocks) {
+		let found = false;
+
+		for (const repo of repoPaths) {
+			// we unwrap because we already checked this
+			const providerInfo = (await gitProviders.getProviderInfo(repo)).unwrap();
+
+			const fullSpecifier = `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier.specifier}`;
+
+			const block = blocksMap.get(fullSpecifier);
+
+			if (block === undefined) continue;
+
+			found = true;
+
+			process.stdout.write(`${L}\n`);
+
+			process.stdout.write(`${L}  ${fullSpecifier}\n`);
+
+			fullSpecifier;
+
+			for (const file of block.files) {
+				// skip test files if not included
+				if (!config.includeTests && isTestFile(file)) continue;
+
+				process.stdout.write(`${L}\n`);
+
+				const sourcePath = path.join(block.directory, file);
+
+				const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, sourcePath);
+
+				const response = await fetch(rawUrl);
+
+				if (!response.ok) {
+					program.error(color.red(`There was an error trying to get ${fullSpecifier}`));
+				}
+
+				let remoteContent = await response.text();
+
+				let localPath = path.join(config.path, block.category, file);
+				if (block.subdirectory) {
+					localPath = path.join(config.path, block.category, block.name, file);
+				}
+
+				let fileContent = '';
+				if (fs.existsSync(localPath)) {
+					fileContent = fs.readFileSync(localPath).toString();
+				}
+
+				if (config.watermark) {
+					const lang = languages.find((lang) => lang.matches(sourcePath));
+
+					if (lang) {
+						const watermark = getWatermark(context.package.version, repo);
+
+						const comment = lang.comment(watermark);
+
+						remoteContent = `${comment}\n\n${remoteContent}`;
+					}
+				}
+
+				const changes = diffLines(fileContent, remoteContent);
+
+				const from = path
+					.join(
+						`${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}`,
+						sourcePath
+					)
+					.replaceAll('\\', '/');
+
+				const to = localPath.replaceAll('\\', '/');
+
+				const formattedDiff = formatDiff({
+					from,
+					to,
+					changes,
+					expand: options.expand,
+					maxUnchanged: options.maxUnchanged,
+					colorAdded: color.greenBright,
+					colorRemoved: color.redBright,
+					prefix: () => `${L}  `,
+					onUnchanged: ({ from, to, prefix }) =>
+						`${prefix?.() ?? ''}${color.cyan(from)} → ${color.gray(to)} ${color.gray('(unchanged)')}\n`,
+					intro: ({ from, to, changes, prefix }) => {
+						const totalChanges = changes.filter((a) => a.added).length;
+
+						return `${prefix?.() ?? ''}${color.cyan(from)} → ${color.gray(to)} (${totalChanges} change${
+							totalChanges === 1 ? '' : 's'
+						})\n${prefix?.() ?? ''}\n`;
+					},
+				});
+
+				process.stdout.write(formattedDiff);
+			}
+
+			break;
+		}
+
+		if (!found) {
+			program.error(
+				color.red(`Invalid block! ${color.bold(blockSpecifier)} does not exist!`)
+			);
+		}
+	}
+
+	outro(color.green('All done!'));
+};
+
+export { diff };

package/src/commands/index.ts

@@ -0,0 +1,7 @@
+import { add } from './add';
+import { build } from './build';
+import { diff } from './diff';
+import { init } from './init';
+import { test } from './test';
+
+export { add, init, test, build, diff };

package/src/commands/init.ts

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import { cancel, confirm, isCancel, outro, spinner, text } from '@clack/prompts';
+import color from 'chalk';
+import { Command } from 'commander';
+import * as v from 'valibot';
+import { context } from '..';
+import { CONFIG_NAME, type Config, getConfig } from '../config';
+import { intro } from '../utils/prompts';
+
+const schema = v.object({
+	path: v.optional(v.string()),
+	tests: v.optional(v.boolean()),
+	repos: v.optional(v.array(v.string())),
+	watermark: v.boolean(),
+});
+
+type Options = v.InferInput<typeof schema>;
+
+const init = new Command('init')
+	.description('Initializes the configuration file')
+	.option('--path <path>', 'Path to install the blocks')
+	.option('--repos [repos...]', 'Repository to install the blocks from')
+	.option(
+		'--no-watermark',
+		'Will not add a watermark to each file upon adding it to your project.'
+	)
+	.option('--tests', 'Will include tests along with the functions.')
+	.action(async (opts) => {
+		const options = v.parse(schema, opts);
+
+		await _init(options);
+	});
+
+const _init = async (options: Options) => {
+	intro(context.package.version);
+
+	const initialConfig = getConfig();
+
+	const loading = spinner();
+
+	if (!options.path) {
+		const result = await text({
+			message: 'Where should we add the blocks?',
+			validate(value) {
+				if (value.trim() === '') return 'Please provide a value';
+			},
+			initialValue: initialConfig.isOk() ? initialConfig.unwrap().path : 'src/blocks',
+		});
+
+		if (isCancel(result)) {
+			cancel('Canceled!');
+			process.exit(0);
+		}
+
+		options.path = result;
+	}
+
+	if (!options.repos) {
+		options.repos = initialConfig.isOk() ? initialConfig.unwrap().repos : [];
+
+		while (true) {
+			if (options.repos.length > 0) {
+				const confirmResult = await confirm({
+					message: 'Add another repo?',
+					initialValue: false,
+				});
+
+				if (isCancel(confirmResult)) {
+					cancel('Canceled!');
+					process.exit(0);
+				}
+
+				if (!confirmResult) break;
+			}
+
+			const result = await text({
+				message: 'Where should we download the blocks from?',
+				placeholder: 'github/ieedan/std',
+				validate: (val) => {
+					if (!val.startsWith('https://github.com') && !val.startsWith('github/')) {
+						return `Must be a ${color.bold('GitHub')} repository!`;
+					}
+				},
+			});
+
+			if (isCancel(result)) {
+				cancel('Canceled!');
+				process.exit(0);
+			}
+
+			options.repos.push(result);
+		}
+	}
+
+	const config: Config = {
+		$schema: `https://unpkg.com/jsrepo@${context.package.version}/schema.json`,
+		repos: options.repos,
+		path: options.path,
+		includeTests:
+			initialConfig.isOk() && options.tests === undefined
+				? initialConfig.unwrap().includeTests
+				: (options.tests ?? false),
+		watermark: options.watermark,
+	};
+
+	loading.start(`Writing config to \`${CONFIG_NAME}\``);
+
+	fs.writeFileSync(CONFIG_NAME, `${JSON.stringify(config, null, '\t')}\n`);
+
+	fs.mkdirSync(config.path, { recursive: true });
+
+	loading.stop(`Wrote config to \`${CONFIG_NAME}\`.`);
+
+	outro(color.green('All done!'));
+};
+
+export { init };

package/src/commands/test.ts

@@ -0,0 +1,369 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cancel, confirm, isCancel, outro, spinner } from '@clack/prompts';
+import color from 'chalk';
+import { Argument, Command, program } from 'commander';
+import { execa } from 'execa';
+import { resolveCommand } from 'package-manager-detector/commands';
+import { detect } from 'package-manager-detector/detect';
+import { Project } from 'ts-morph';
+import * as v from 'valibot';
+import { context } from '..';
+import { getConfig } from '../config';
+import { INFO } from '../utils';
+import { type Block, categorySchema, isTestFile } from '../utils/build';
+import { getInstalledBlocks } from '../utils/get-installed-blocks';
+import * as gitProviders from '../utils/git-providers';
+import { OUTPUT_FILE } from '../utils/index';
+import { intro } from '../utils/prompts';
+
+const schema = v.object({
+	debug: v.boolean(),
+	verbose: v.boolean(),
+	repo: v.optional(v.string()),
+	allow: v.boolean(),
+});
+
+type Options = v.InferInput<typeof schema>;
+
+const test = new Command('test')
+	.description('Tests blocks against most recent tests')
+	.addArgument(new Argument('[blocks...]', 'Whichever blocks you want to test.').default([]))
+	.option('--verbose', 'Include debug logs.', false)
+	.option('-A, --allow', 'Allow jsrepo to download code from the provided repo.', false)
+	.option('--repo <repo>', 'Repository to download the blocks from')
+	.option('--debug', 'Leaves the temp test file around for debugging upon failure.', false)
+	.action(async (blockNames, opts) => {
+		const options = v.parse(schema, opts);
+
+		await _test(blockNames, options);
+	});
+
+type RemoteBlock = Block & { sourceRepo: gitProviders.Info };
+
+const _test = async (blockNames: string[], options: Options) => {
+	intro(context.package.version);
+
+	const verbose = (msg: string) => {
+		if (options.verbose) {
+			console.info(`${INFO} ${msg}`);
+		}
+	};
+
+	verbose(`Attempting to test ${JSON.stringify(blockNames)}`);
+
+	const config = getConfig().match(
+		(val) => val,
+		(err) => program.error(color.red(err))
+	);
+
+	const loading = spinner();
+
+	const blocksMap: Map<string, RemoteBlock> = new Map();
+
+	let repoPaths = config.repos;
+
+	// we just want to override all others if supplied via the CLI
+	if (options.repo) repoPaths = [options.repo];
+
+	if (!options.allow && options.repo) {
+		const result = await confirm({
+			message: `Allow ${color.cyan('jsrepo')} to download and run code from ${color.cyan(options.repo)}?`,
+			initialValue: true,
+		});
+
+		if (isCancel(result) || !result) {
+			cancel('Canceled!');
+			process.exit(0);
+		}
+	}
+
+	verbose(`Fetching blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	if (!options.verbose) loading.start(`Fetching blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	for (const repo of repoPaths) {
+		const providerInfo: gitProviders.Info = (await gitProviders.getProviderInfo(repo)).match(
+			(info) => info,
+			(err) => program.error(color.red(err))
+		);
+
+		const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+
+		verbose(`Got info for provider ${color.cyan(providerInfo.name)}`);
+
+		const response = await fetch(manifestUrl);
+
+		if (!response.ok) {
+			if (!options.verbose) loading.stop(`Error fetching ${color.cyan(manifestUrl.href)}`);
+			program.error(
+				color.red(
+					`There was an error fetching the \`${OUTPUT_FILE}\` from the repository ${color.cyan(
+						repo
+					)} make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+				)
+			);
+		}
+
+		const categories = v.parse(v.array(categorySchema), await response.json());
+
+		for (const category of categories) {
+			for (const block of category.blocks) {
+				// blocks will override each other
+				blocksMap.set(
+					`${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+					{
+						...block,
+						sourceRepo: providerInfo,
+					}
+				);
+			}
+		}
+	}
+
+	verbose(`Retrieved blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	if (!options.verbose) loading.stop(`Retrieved blocks from ${color.cyan(repoPaths.join(', '))}`);
+
+	const tempTestDirectory = `blocks-tests-temp-${Date.now()}`;
+
+	verbose(`Trying to create the temp directory ${color.bold(tempTestDirectory)}.`);
+
+	fs.mkdirSync(tempTestDirectory, { recursive: true });
+
+	const cleanUp = () => {
+		fs.rmSync(tempTestDirectory, { recursive: true, force: true });
+	};
+
+	const installedBlocks = getInstalledBlocks(blocksMap, config).map((val) => val.specifier);
+
+	let testingBlocks = blockNames;
+
+	// in the case that we want to test all files
+	if (blockNames.length === 0) {
+		testingBlocks = installedBlocks;
+	}
+
+	if (testingBlocks.length === 0) {
+		cleanUp();
+		program.error(color.red('There were no blocks found in your project!'));
+	}
+
+	const testingBlocksMapped: { name: string; block: RemoteBlock }[] = [];
+
+	for (const blockSpecifier of testingBlocks) {
+		let block: RemoteBlock | undefined = undefined;
+
+		// if the block starts with github (or another provider) we know it has been resolved
+		if (!blockSpecifier.startsWith('github')) {
+			for (const repo of repoPaths) {
+				// we unwrap because we already checked this
+				const providerInfo = (await gitProviders.getProviderInfo(repo)).unwrap();
+
+				const tempBlock = blocksMap.get(
+					`${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier}`
+				);
+
+				if (tempBlock === undefined) continue;
+
+				block = tempBlock;
+
+				break;
+			}
+		} else {
+			if (repoPaths.length === 0) {
+				const [providerName, owner, repoName, ...rest] = blockSpecifier.split('/');
+
+				let repo: string;
+				// if rest is greater than 2 it isn't the block specifier so it is part of the path
+				if (rest.length > 2) {
+					repo = `${providerName}/${owner}/${repoName}/${rest.join('/')}`;
+				} else {
+					repo = `${providerName}/${owner}/${repoName}`;
+				}
+
+				const providerInfo = (await gitProviders.getProviderInfo(repo)).match(
+					(val) => val,
+					(err) => program.error(color.red(err))
+				);
+
+				const manifestUrl = await providerInfo.provider.resolveRaw(
+					providerInfo,
+					OUTPUT_FILE
+				);
+
+				const categories = (await gitProviders.getManifest(manifestUrl)).match(
+					(val) => val,
+					(err) => program.error(color.red(err))
+				);
+
+				for (const category of categories) {
+					for (const block of category.blocks) {
+						blocksMap.set(
+							`${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+							{
+								...block,
+								sourceRepo: providerInfo,
+							}
+						);
+					}
+				}
+			}
+
+			block = blocksMap.get(blockSpecifier);
+		}
+
+		if (!block) {
+			program.error(
+				color.red(`Invalid block! ${color.bold(blockSpecifier)} does not exist!`)
+			);
+		}
+
+		testingBlocksMapped.push({ name: blockSpecifier, block });
+	}
+
+	for (const { name: specifier, block } of testingBlocksMapped) {
+		const providerInfo = block.sourceRepo;
+
+		if (!options.verbose) {
+			loading.start(`Setting up test file for ${color.cyan(specifier)}`);
+		}
+
+		if (!block.tests) {
+			loading.stop(`No tests found for ${color.cyan(specifier)}`);
+			continue;
+		}
+
+		const getSourceFile = async (filePath: string) => {
+			const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
+
+			const response = await fetch(rawUrl);
+
+			if (!response.ok) {
+				loading.stop(color.red(`Error fetching ${color.bold(rawUrl.href)}`));
+				program.error(color.red(`There was an error trying to get ${specifier}`));
+			}
+
+			return await response.text();
+		};
+
+		verbose(`Downloading and copying test files for ${specifier}`);
+
+		const testFiles: string[] = [];
+
+		for (const testFile of block.files.filter((file) => isTestFile(file))) {
+			const content = await getSourceFile(path.join(block.directory, testFile));
+
+			const destPath = path.join(tempTestDirectory, testFile);
+
+			fs.writeFileSync(destPath, content);
+
+			testFiles.push(destPath);
+		}
+
+		const directory = path.join(config.path, block.category);
+		let blockFilePath = path.join(directory, `${block.name}`);
+
+		blockFilePath = blockFilePath.replaceAll('\\', '/');
+
+		verbose(`${color.bold(specifier)} file path is ${color.bold(blockFilePath)}`);
+
+		const project = new Project();
+
+		// resolve imports for the block
+		for (const file of testFiles) {
+			verbose(`Opening test file ${file}`);
+
+			const tempFile = project.addSourceFileAtPath(file);
+
+			for (const importDeclaration of tempFile.getImportDeclarations()) {
+				const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+
+				let newModuleSpecifier: string | undefined = undefined;
+
+				// if the module is relative resolve it relative to the new path of the tests
+				if (moduleSpecifier.startsWith('.')) {
+					if (block.subdirectory) {
+						newModuleSpecifier = path.join(
+							'../',
+							config.path,
+							block.category,
+							block.name,
+							moduleSpecifier
+						);
+					} else {
+						newModuleSpecifier = path.join(
+							'../',
+							config.path,
+							block.category,
+							moduleSpecifier
+						);
+					}
+				}
+
+				if (newModuleSpecifier) {
+					// we need to add the replace so that paths are correctly translated on windows
+					importDeclaration.setModuleSpecifier(newModuleSpecifier.replaceAll(/\\/g, '/'));
+				}
+			}
+		}
+
+		project.saveSync();
+
+		verbose(`Completed ${color.cyan.bold(specifier)} test file`);
+
+		if (!options.verbose) {
+			loading.stop(`Completed setup for ${color.bold(specifier)}`);
+		}
+	}
+
+	verbose('Beginning testing');
+
+	const pm = await detect({ cwd: process.cwd() });
+
+	if (pm == null) {
+		program.error(color.red('Could not detect package manager'));
+	}
+
+	const resolved = resolveCommand(pm.agent, 'execute', ['vitest', 'run', tempTestDirectory]);
+
+	if (resolved == null) {
+		program.error(color.red(`Could not resolve add command for '${pm.agent}'.`));
+	}
+
+	const { command, args } = resolved;
+
+	const testCommand = `${command} ${args.join(' ')}`;
+
+	const testingProcess = execa({
+		cwd: process.cwd(),
+		stdio: ['ignore', 'pipe', 'pipe'],
+	})`${testCommand}`;
+
+	const handler = (data: string) => console.info(data.toString());
+
+	testingProcess.stdout.on('data', handler);
+	testingProcess.stderr.on('data', handler);
+
+	try {
+		await testingProcess;
+
+		cleanUp();
+
+		outro(color.green('All done!'));
+	} catch (err) {
+		if (options.debug) {
+			console.info(
+				`${color.bold('--debug')} flag provided. Skipping cleanup. Run '${color.bold(
+					testCommand
+				)}' to retry tests.\n`
+			);
+		} else {
+			cleanUp();
+		}
+
+		program.error(color.red(`Tests failed! Error ${err}`));
+	}
+};
+
+export { test };