startx 1.0.92 → 1.1.1

package/apps/startx-cli/src/commands/init.ts

@@ -26,6 +26,8 @@ export class InitCommand {
 		const prefs = await this.getPrefs({ projectName, options, projects: availableApps });
 		const nonAppPackages = packageList.filter(pkg => pkg.type !== "apps");
 
+		await this.checkTargetDirectory(prefs.directory.workspace);
+
 		const config = await this.getConfigPrefs({
 			selectedApps: prefs.selectedApps,
 			packages: nonAppPackages,
@@ -40,7 +42,7 @@ export class InitCommand {
 		const workspaceTags = [...packagePrefs.gTags, "runnable"] as TAGS[];
 		await this.installWorkspace({
 			name: prefs.projectName,
-			tags: [...workspaceTags, "runnable"],
+			tags: workspaceTags,
 			dir: prefs.directory,
 		});
 
@@ -307,24 +309,48 @@ export class InitCommand {
 
 	private static async writeVscodeSettings(props: { workspace: string; tags: TAGS[] }) {
 		const usesBiome = props.tags.includes("biome");
+		const vscodeDir = path.join(props.workspace, ".vscode");
 
 		const settings: Record<string, unknown> = {
 			"editor.formatOnSave": true,
 			"editor.defaultFormatter": usesBiome ? "biomejs.biome" : "esbenp.prettier-vscode",
 			"editor.codeActionsOnSave": {
-				...(usesBiome ? { "source.organizeImports.biome": "explicit" } : {}),
+				...(usesBiome
+					? {
+							"source.organizeImports.biome": "explicit",
+							"source.fixAll.biome": "explicit",
+						}
+					: {}),
 				"source.fixAll.eslint": "explicit",
-				"js/ts.suggest.autoImports": "explicit",
 				"source.fixAll": "explicit",
 			},
 			"eslint.workingDirectories": [{ "mode": "auto" }],
 		};
 
-		await fsTool.writeJSONFile({
-			dir: path.join(props.workspace, ".vscode"),
-			file: "settings",
-			content: settings,
+		const extensions = {
+			recommendations: ["dbaeumer.vscode-eslint", ...(usesBiome ? ["biomejs.biome"] : ["esbenp.prettier-vscode"])],
+		};
+
+		await Promise.all([
+			fsTool.writeJSONFile({ dir: vscodeDir, file: "settings", content: settings }),
+			fsTool.writeJSONFile({ dir: vscodeDir, file: "extensions", content: extensions }),
+		]);
+	}
+
+	private static async checkTargetDirectory(workspace: string) {
+		const [files, dirs] = await Promise.all([
+			fsTool.listFiles({ dir: workspace }),
+			fsTool.listDirectories({ dir: workspace }),
+		]);
+		if (files.length === 0 && dirs.length === 0) return;
+
+		const overwrite = await CommonInquirer.confirm({
+			message: `Directory "${workspace}" already exists and is not empty. Overwrite?`,
+			default: false,
 		});
+		if (!overwrite) {
+			throw new Error("Aborted: target directory already exists.");
+		}
 	}
 
 	// Helpers

package/apps/startx-cli/src/commands/package.ts

@@ -6,6 +6,7 @@ import fs from "fs/promises";
 import path from "path";
 import z from "zod";
 
+import { DepCheck } from "../configs/deps";
 import { FileCheck } from "../configs/files";
 import type { StartXPackageJson, TAGS } from "../types";
 import { CliUtils, type PackageItem } from "../utils/cli-utils";
@@ -15,6 +16,7 @@ import { CommonInquirer } from "../utils/inquirer";
 type PackageOptions = {
 	eslint?: boolean;
 	install?: boolean;
+	name?: string;
 };
 
 type NewPackageOptions = PackageOptions & {
@@ -39,11 +41,12 @@ export class PackageCommand {
 		)
 		.addCommand(
 			new Command("add")
-				.description("Add an existing StartX package by name.")
+				.description("Add an existing StartX app or package, optionally with a new name.")
 				.argument("[packageName]")
+				.option("-n, --name <name>", "override the name for the added package")
 				.option("--eslint", "enable ESLint support for the added package")
 				.option("--no-eslint", "skip ESLint support for the added package")
-				.option("--no-install", "do not run the package manager after updating ESLint")
+				.option("--no-install", "do not run the package manager after updating dependencies")
 				.action(PackageCommand.add.bind(PackageCommand))
 		)
 		.addCommand(
@@ -85,7 +88,7 @@ export class PackageCommand {
 		const selectedName =
 			packageName ??
 			(await CommonInquirer.choose({
-				message: "Select package to add",
+				message: "Select app or package to add",
 				options: availablePackages.map(pkg => pkg.name),
 				mode: "single",
 				required: true,
@@ -96,6 +99,16 @@ export class PackageCommand {
 			throw new Error(`Package "${selectedName}" was not found in the StartX template.`);
 		}
 
+		const templateName = selectedPackage.packageJson?.name ?? selectedPackage.name;
+		const overrideName =
+			options.name ??
+			(await CommonInquirer.getText({
+				message: "Name for the new package (leave unchanged to keep the original)",
+				name: "overrideName",
+				default: templateName,
+				schema: packageNameSchema,
+			}));
+
 		const directory = CliUtils.getDirectory();
 		const eslintEnabled = await this.resolveEslintPreference(options);
 		const packagesToInstall = this.resolvePackageClosure({
@@ -109,15 +122,24 @@ export class PackageCommand {
 			eslintEnabled,
 		});
 
+		await this.checkAndInstallMissingDeps({
+			workspace: directory.workspace,
+			tags,
+			install: options.install,
+		});
+
 		for (const pkg of packagesToInstall) {
+			const isMain = pkg.name === selectedPackage.name;
 			await this.installTemplatePackage({
 				pkg,
 				directory,
 				tags,
+				overrideName: isMain ? overrideName : undefined,
+				overrideRelativePath: isMain ? this.getDestinationPath(pkg.relativePath, overrideName) : undefined,
 			});
 		}
 
-		logger.info(`Package add complete: ${selectedPackage.name}`);
+		logger.info(`Done! Run \`pnpm install\` to link the new package.`);
 	}
 
 	private static async create(packageName: string | undefined, options: NewPackageOptions) {
@@ -136,8 +158,11 @@ export class PackageCommand {
 			throw new Error(`Package directory already exists: ${packageDir}`);
 		}
 
+		const rootPackage = await this.readRootPackage(directory.workspace);
 		const eslintEnabled = await this.resolveEslintPreference(options);
+		const vitestEnabled = this.hasDependency(rootPackage, "vitest");
 		const packages = await CliUtils.getPackageList();
+
 		await this.ensureTemplatePackage({
 			packages,
 			name: "typescript-config",
@@ -154,8 +179,20 @@ export class PackageCommand {
 			});
 		}
 
+		if (vitestEnabled) {
+			await this.ensureTemplatePackage({
+				packages,
+				name: "vitest-config",
+				directory,
+				tags: ["common", "node", "vitest"],
+			});
+		}
+
 		await fs.mkdir(path.join(packageDir, "src"), { recursive: true });
-		await this.writeJson(path.join(packageDir, "package.json"), this.createPackageJson({ name, eslintEnabled }));
+		await this.writeJson(
+			path.join(packageDir, "package.json"),
+			this.createPackageJson({ name, eslintEnabled, vitestEnabled })
+		);
 		await fs.writeFile(
 			path.join(packageDir, "tsconfig.json"),
 			`${JSON.stringify(
@@ -181,7 +218,15 @@ export class PackageCommand {
 			);
 		}
 
+		if (vitestEnabled) {
+			await fs.writeFile(
+				path.join(packageDir, "vitest.config.ts"),
+				`import vitestConfig from "vitest-config/node";\n\nexport default vitestConfig;\n`
+			);
+		}
+
 		logger.info(`Created package ${name} at ${path.relative(directory.workspace, packageDir)}`);
+		logger.info(`Run \`pnpm install\` to link the new package.`);
 	}
 
 	private static async resolveEslintPreference(options: PackageOptions) {
@@ -228,6 +273,7 @@ export class PackageCommand {
 		if (this.hasDependency(rootPackage, "@biomejs/biome")) tags.add("biome");
 		if (this.hasDependency(rootPackage, "prettier")) tags.add("prettier");
 		if (this.hasDependency(rootPackage, "vitest")) tags.add("vitest");
+		if (this.hasDependency(rootPackage, "tsdown")) tags.add("tsdown");
 
 		for (const pkg of props.packages) {
 			pkg.packageJson?.startx?.tags?.forEach(tag => tags.add(tag));
@@ -295,15 +341,25 @@ export class PackageCommand {
 		pkg: PackageItem;
 		directory: ReturnType<typeof CliUtils.getDirectory>;
 		tags: TAGS[];
+		overrideName?: string;
+		overrideRelativePath?: string;
 	}) {
 		if (!props.pkg.packageJson) {
 			throw new Error(`Missing package.json for ${props.pkg.name}`);
 		}
 
-		const destination = path.join(props.directory.workspace, props.pkg.relativePath);
+		const relativePath = props.overrideRelativePath ?? props.pkg.relativePath;
+		const destination = path.join(props.directory.workspace, relativePath);
+
 		if (await this.pathExists(path.join(destination, "package.json"))) {
-			logger.info(`Skipping ${props.pkg.name}; it already exists.`);
-			return;
+			const overwrite = await CommonInquirer.confirm({
+				message: `"${relativePath}" already exists. Overwrite?`,
+				default: false,
+			});
+			if (!overwrite) {
+				logger.info(`Skipping ${props.pkg.name}.`);
+				return;
+			}
 		}
 
 		const tags = new Set<TAGS>([...props.tags, ...(props.pkg.packageJson.startx?.tags ?? [])]);
@@ -314,7 +370,7 @@ export class PackageCommand {
 		const { packageJson, isWorkspace } = FileHandler.handlePackageJson({
 			app: props.pkg.packageJson,
 			tags: Array.from(tags),
-			name: props.pkg.packageJson.name || props.pkg.name,
+			name: props.overrideName ?? props.pkg.packageJson.name ?? props.pkg.name,
 		});
 
 		if (isWorkspace) {
@@ -329,7 +385,7 @@ export class PackageCommand {
 			exclude: !tags.has("vitest") ? /\.test\.tsx?$/ : undefined,
 		});
 
-		logger.info(`Installed ${props.pkg.name}`);
+		logger.info(`Installed ${props.overrideName ?? props.pkg.name} at ${relativePath}`);
 	}
 
 	private static async copyValidatedFilesFromFolder(source: string, destination: string, tags: Set<TAGS>) {
@@ -346,7 +402,7 @@ export class PackageCommand {
 		}
 	}
 
-	private static createPackageJson(props: { name: string; eslintEnabled: boolean }) {
+	private static createPackageJson(props: { name: string; eslintEnabled: boolean; vitestEnabled: boolean }) {
 		const scripts: Record<string, string> = {
 			typecheck: "tsc --noEmit",
 			clean: "rimraf dist .turbo",
@@ -354,11 +410,21 @@ export class PackageCommand {
 		const devDependencies: Record<string, string> = {
 			"typescript-config": "workspace:*",
 		};
+		const ignore: string[] = [];
 
 		if (props.eslintEnabled) {
 			scripts.lint = "eslint .";
 			scripts["lint:fix"] = "eslint . --fix";
 			devDependencies["eslint-config"] = "workspace:*";
+		} else {
+			ignore.push("eslint-config");
+		}
+
+		if (props.vitestEnabled) {
+			scripts.test = "vitest run";
+			devDependencies["vitest-config"] = "workspace:*";
+		} else {
+			ignore.push("vitest-config");
 		}
 
 		return {
@@ -371,11 +437,66 @@ export class PackageCommand {
 			startx: {
 				iTags: ["node"],
 				requiredDevDeps: ["typescript-config"],
-				...(props.eslintEnabled ? {} : { ignore: ["eslint-config"] }),
+				...(ignore.length > 0 ? { ignore } : {}),
 			},
 		};
 	}
 
+	private static async checkAndInstallMissingDeps(props: {
+		workspace: string;
+		tags: TAGS[];
+		install?: boolean;
+	}) {
+		const rootPackage = await this.readRootPackage(props.workspace);
+		const pnpmWorkspace = await CliUtils.parsePnpmWorkspace({ dir: props.workspace });
+
+		const missing: Array<{ name: string; version: string; isDev: boolean }> = [];
+		for (const [dep, config] of Object.entries(DepCheck)) {
+			if (!config.tags.every(tag => props.tags.includes(tag as TAGS))) continue;
+			if (config.tags.includes("root")) continue;
+			if (this.hasDependency(rootPackage, dep)) continue;
+			const version = pnpmWorkspace?.catalog?.[dep] ? "catalog:" : config.version;
+			missing.push({ name: dep, version, isDev: config.isDevDependency ?? true });
+		}
+
+		if (missing.length === 0) return;
+
+		logger.warn(`The following workspace dependencies are required but not installed:`);
+		for (const dep of missing) {
+			logger.warn(`  - ${dep.name}`);
+		}
+
+		const shouldAdd = await CommonInquirer.confirm({
+			message: "Add them to the workspace root package.json?",
+			default: true,
+		});
+		if (!shouldAdd) {
+			logger.warn("Skipping. Some features may not work correctly without these dependencies.");
+			return;
+		}
+
+		for (const dep of missing) {
+			if (dep.isDev) {
+				(rootPackage.devDependencies as Record<string, string>)[dep.name] = dep.version;
+			} else {
+				(rootPackage.dependencies as Record<string, string>)[dep.name] = dep.version;
+			}
+		}
+
+		await this.writeJson(path.join(props.workspace, "package.json"), rootPackage);
+		logger.info("Added missing dependencies to root package.json.");
+
+		if (props.install !== false) {
+			await this.installRootDependencies(props.workspace);
+		}
+	}
+
+	private static getDestinationPath(templateRelativePath: string, newName: string): string {
+		const parentDir = path.dirname(templateRelativePath);
+		const leafName = newName.includes("/") ? newName.split("/").pop()! : newName;
+		return path.join(parentDir, leafName);
+	}
+
 	private static getDefaultPackagePath(name: string) {
 		if (name.startsWith("@")) {
 			const [scope, packageName] = name.split("/");

package/apps/startx-cli/src/configs/files.ts

@@ -16,6 +16,9 @@ export const FileCheck: WHITELIST_FILES = {
 	".prettierignore": {
 		tags: ["biome"],
 	},
+	"README.md": {
+		tags: ["never"],
+	},
 	"biome.json": {
 		tags: ["biome"],
 	},

package/apps/startx-cli/src/configs/scripts.ts

@@ -93,7 +93,7 @@ export const scripts: SCRIPT = {
 			tags: ["node", "eslint", "root"],
 		},
 		{
-			script: "eslint . src/**/*.ts --fix",
+			script: "eslint . --fix",
 			tags: ["node", "eslint"],
 		},
 	],
@@ -118,64 +118,74 @@ export const scripts: SCRIPT = {
 		},
 	],
 	"db:push": [
+		{
+			script: "turbo run db:push",
+			tags: ["db", "root"],
+		},
 		{
 			script: "drizzle-kit push",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:studio": [
 		{
-			script: "turbo run db:push",
+			script: "turbo run db:studio",
 			tags: ["db", "root"],
 		},
-	],
-	"db:studio": [
 		{
 			script: "drizzle-kit studio",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:pull": [
 		{
-			script: "turbo run db:studio",
+			script: "turbo run db:pull",
 			tags: ["db", "root"],
 		},
-	],
-	"db:pull": [
 		{
 			script: "drizzle-kit pull",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:generate": [
 		{
-			script: "turbo run db:pull",
+			script: "turbo run db:generate",
 			tags: ["db", "root"],
 		},
-	],
-	"db:generate": [
 		{
 			script: "drizzle-kit generate",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:migrate": [
 		{
-			script: "turbo run db:generate",
+			script: "turbo run db:migrate",
 			tags: ["db", "root"],
 		},
-	],
-	"db:migrate": [
 		{
 			script: "drizzle-kit migrate",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:check": [
 		{
-			script: "turbo run db:migrate",
+			script: "turbo run db:check",
 			tags: ["db", "root"],
 		},
-	],
-	"db:check": [
 		{
 			script: "drizzle-kit check",
 			tags: ["drizzle", "db"],
 		},
+	],
+	"db:up": [
 		{
-			script: "turbo run db:check",
+			script: "turbo run db:up",
 			tags: ["db", "root"],
 		},
+		{
+			script: "drizzle-kit up",
+			tags: ["drizzle", "db"],
+		},
 	],
 	"typecheck": [
 		{

package/apps/startx-cli/src/index.ts

@@ -3,6 +3,7 @@ import { logger } from "@repo/logger";
 import { Command } from "commander";
 
 import { InitCommand } from "./commands/init";
+import { PackageCommand } from "./commands/package";
 import { version } from "../../../package.json";
 
 const program = new Command();
@@ -14,6 +15,6 @@ program.command("ping").action(() => {
 });
 
 program.addCommand(InitCommand.command);
-// program.addCommand(PackageCommand.command);
+program.addCommand(PackageCommand.command);
 
 program.parse(process.argv);

package/apps/startx-cli/src/utils/file-handler.ts

@@ -27,9 +27,9 @@ export class FileHandler {
 		tags: TAGS[];
 		dependencies?: Record<string, string>;
 	}) {
-		const isWorkspace = !!props.app.devDependencies?.turbo;
+		const isWorkspace = props.tags.includes("root");
 
-		const tags = isWorkspace ? [...props.tags, "root"] : [...props.tags];
+		const tags = [...props.tags];
 		const workspaceAttr: Record<string, unknown> = isWorkspace
 			? {
 					version: "1.0.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "startx",
   "description": "",
-  "version": "1.0.92",
+  "version": "1.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/avinashid/startx.git"