intershell 0.3.0

package/src/commands/dev/check.ts

@@ -0,0 +1,117 @@
+import { setTimeout } from "node:timers/promises";
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+import { EntityCompose, type ServiceHealth, type ServiceInfo } from "../../entities";
+
+export default class DevCheck extends Command {
+	static description = "Check the health of the DevContainer services";
+
+	static examples = ["intershell dev:check", "intershell dev:check --keep-alive"];
+
+	static flags = {
+		"keep-alive": Flags.boolean({
+			char: "s",
+			description: "Keep services alive after checks complete",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(DevCheck);
+
+		this.log(colorify.blue("🧪 Starting DevContainer Health Check..."));
+
+		await $`bun run dev:up --build`;
+		const compose = new EntityCompose("./docker-compose.dev.yml");
+		await this.monitorServiceHealth(compose);
+
+		this.log(colorify.blue("\n📊 Services are available at:"));
+		const devUrls = await compose.getServiceUrls();
+		for (const [name, url] of Object.entries(devUrls)) {
+			this.log(colorify.cyan(`   • ${name}: ${url}`));
+		}
+		this.log(colorify.green("✅ DevContainer health check completed successfully!"));
+
+		if (flags["keep-alive"]) {
+			this.log(
+				colorify.yellow("💡 Use 'intershell dev:check --keep-alive' to keep services alive"),
+			);
+		} else {
+			this.log(colorify.yellow("🧹 Cleaning up services..."));
+			await $`bun run dev:down`;
+		}
+	}
+
+	private readonly icons: Record<ServiceHealth["status"], string> = {
+		healthy: "✅",
+		starting: "🔄",
+		unhealthy: "❌",
+		unknown: "❓",
+	};
+
+	private readonly colors: Record<ServiceHealth["status"], (text: string) => string> = {
+		healthy: colorify.green,
+		starting: colorify.yellow,
+		unhealthy: colorify.red,
+		unknown: colorify.gray,
+	};
+
+	private async monitorServiceHealth(compose: EntityCompose): Promise<void> {
+		const services = await compose.getServices();
+		this.log(colorify.yellow("⏳ Waiting for services to become healthy..."));
+
+		const retryInterval = 5_000;
+		const maxRetries = 6; // 6 * retryInterval = 30 seconds total
+		let retryCount = 0;
+		let allHealthy = false;
+
+		let healthResult: ServiceHealth[] | null = null;
+		while (retryCount < maxRetries && !allHealthy) {
+			if (retryCount > 0) {
+				this.log(
+					colorify.yellow(
+						`🔄 Retry ${retryCount}/${maxRetries} - Checking health again in 5 seconds...`,
+					),
+				);
+				await setTimeout(retryInterval);
+			}
+
+			healthResult = await compose.getServiceHealth();
+
+			if (
+				healthResult?.every((s) => s.status === "healthy") &&
+				healthResult.length === services.length
+			) {
+				allHealthy = true;
+			} else {
+				retryCount++;
+			}
+		}
+
+		// Print detailed health status
+		this.log(colorify.blue("\n📊 Final Service Health Status:"));
+		this.log("-".repeat(50));
+		if (!healthResult) {
+			throw new Error("Failed to get health status from services");
+		}
+
+		for (const service of healthResult) {
+			const icon = this.icons[service.status];
+			const color = this.colors[service.status];
+			const port = services.find((s: ServiceInfo) => s.name === service.name)?.ports[0]?.host;
+			this.log(`${icon} ${color(service.name)}: ${service.status} ${port ? `(${port})` : ""}`);
+		}
+
+		if (healthResult.some((s) => s.status === "unhealthy")) {
+			throw new Error(
+				`Unhealthy services after ${maxRetries} retries: ${healthResult
+					.filter((s) => s.status === "unhealthy")
+					.map((s) => s.name)
+					.join(", ")}`,
+			);
+		}
+
+		this.log(colorify.green("✅ All services are healthy"));
+	}
+}

package/src/commands/dev/cleanup.ts

@@ -0,0 +1,34 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+
+export default class DevCleanup extends Command {
+	static description = `Clean up DevContainer services and development artifacts.
+This only cleans up the development services, not the VS Code DevContainer itself.
+To stop the VS Code DevContainer, run \`bun run dev:rm\` from the host machine.`;
+
+	static examples = ["intershell dev:cleanup", "intershell dev:cleanup --verbose"];
+
+	static flags = {
+		verbose: Flags.boolean({
+			char: "v",
+			description: "Enable verbose output",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		await this.parse(DevCleanup);
+
+		this.log(colorify.blue("🧹 Starting DevContainer cleanup..."));
+
+		this.log(colorify.yellow("🐳 Stopping DevContainer services..."));
+		await $`docker compose -f ./docker-compose.dev.yml --profile all down --volumes`;
+		await $`docker compose -f ./docker-compose.dev.yml --profile all rm -f --volumes`;
+
+		this.log(colorify.green("✅ DevContainer cleanup completed successfully!"));
+		this.log(colorify.cyan("\n💡 To start fresh on devcontainer, run:"));
+		this.log(colorify.cyan("  - intershell dev:setup"));
+		this.log(colorify.cyan("  - intershell dev:rm # To stop VS Code DevContainer (host only)"));
+	}
+}

package/src/commands/dev/rm.ts

@@ -0,0 +1,66 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+
+export default class DevRm extends Command {
+	static description = `Stop and remove the VS Code DevContainer itself.
+⚠️  WARNING: This script must be run from the HOST machine, not from within the DevContainer.
+This will stop the VS Code DevContainer and all associated containers.`;
+
+	static examples = ["intershell dev:rm", "intershell dev:rm --force"];
+
+	static flags = {
+		force: Flags.boolean({
+			char: "f",
+			description: "Force removal without confirmation",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		await this.parse(DevRm);
+
+		this.log(colorify.blue("🐳 Stopping VS Code DevContainer..."));
+
+		// Check if we're in a DevContainer
+		const isInDevContainer = process.env.REMOTE_CONTAINERS === "true";
+		if (isInDevContainer) {
+			this.error(
+				colorify.red(
+					"❌ ERROR: This script must be run from the HOST machine, not from within the DevContainer.",
+				),
+			);
+			this.log(
+				colorify.yellow(
+					"💡 Please exit the DevContainer and run this command from your host terminal.",
+				),
+			);
+			process.exit(1);
+		}
+
+		await this.stepStopDevContainer();
+		await this.stepStopRemoveAllContainers();
+
+		this.log(colorify.green("✅ DevContainer removal completed successfully!"));
+		this.log(colorify.cyan("\n💡 To start fresh, run:"));
+		this.log(colorify.cyan("  - intershell local:setup # For local development"));
+		this.log(colorify.cyan("  - Press `Ctrl+Shift+P` (or `Cmd+Shift+P` on macOS) "));
+		this.log(colorify.cyan("  -Type 'Dev Containers: Reopen in Container' and select the command"));
+		this.log(colorify.cyan("  - intershell dev:setup # For DevContainer development"));
+	}
+
+	private async stepStopDevContainer(): Promise<void> {
+		this.log(colorify.yellow("🛑 Stopping VS Code DevContainer..."));
+		// Stop the DevContainer using VS Code CLI
+		await $`code --command "devcontainers.stop"`.nothrow();
+	}
+
+	private async stepStopRemoveAllContainers(): Promise<void> {
+		this.log(colorify.yellow("🐳 Stopping all related containers..."));
+		await $`docker compose -f ./docker-compose.dev.yml --profile all down --volumes --remove-orphans`;
+		await $`docker compose -f docker-compose.yml down --volumes --remove-orphans`;
+		this.log(colorify.yellow("🗑️ Removing containers..."));
+		await $`docker compose -f ./docker-compose.dev.yml --profile all rm -f --volumes`;
+		await $`docker compose -f docker-compose.yml rm -f --volumes`;
+	}
+}

package/src/commands/dev/setup.ts

@@ -0,0 +1,48 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+import { EntityCompose } from "../../entities";
+
+export default class DevSetup extends Command {
+	static description =
+		"Setup DevContainer environment with Docker builds, service startup, and health verification";
+
+	static examples = [
+		"intershell dev:setup",
+		"intershell dev:setup --skip-health-check",
+		"intershell dev:setup --keep-running",
+	];
+
+	static flags = {
+		"skip-health-check": Flags.boolean({
+			char: "h",
+			description: "Skip health check verification",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(DevSetup);
+
+		this.log(colorify.blue("🐳 Starting DevContainer setup..."));
+
+		await $`bun run dev:up --build`;
+		if (!flags["skip-health-check"]) {
+			this.log(colorify.blue("🏥 Running health checks..."));
+			await $`bun run dev:check`;
+		}
+
+		this.log(colorify.cyan("\n💡 Services are running and available at:"));
+		const compose = new EntityCompose("./docker-compose.dev.yml");
+		const devUrls = await compose.getServiceUrls();
+		for (const [name, url] of Object.entries(devUrls)) {
+			this.log(colorify.cyan(`   • ${name}: ${url}`));
+		}
+
+		this.log(colorify.yellow("💡 Use 'bun run dev:cleanup' to stop services when done"));
+		this.log(colorify.cyan("\n💡 Useful commands:"));
+		this.log(colorify.cyan(" - bun run dev:check # Check DevContainer health"));
+		this.log(colorify.cyan(" - bun run dev:logs # View service logs"));
+		this.log(colorify.cyan(" - bun run dev:cleanup # Clean DevContainer environment"));
+	}
+}

package/src/commands/local/cleanup.ts

@@ -0,0 +1,74 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+
+export default class LocalCleanup extends Command {
+	static description =
+		"Comprehensive cleanup of Docker containers, build artifacts, and development files. This includes DevContainer cleanup. To stop the VS Code DevContainer itself, run `bun run dev:rm` from host machine";
+
+	static examples = ["intershell local:cleanup", "intershell local:cleanup --verbose"];
+
+	static flags = {
+		verbose: Flags.boolean({
+			char: "v",
+			description: "Enable verbose output",
+			default: false,
+		}),
+	};
+
+	private readonly directories = [
+		"dist",
+		"build",
+		"dist",
+		"dist-storybook",
+		".turbo",
+		".next",
+		".output",
+		"coverage",
+		".nyc_output",
+		".cache",
+		".parcel-cache",
+		".vite",
+		".swc",
+		".act",
+		".biomecache",
+		"bin",
+	];
+
+	private readonly files = [
+		".act-event.json",
+		"*.tsbuildinfo",
+		".log",
+		".tmp",
+		".temp",
+		".DS_Store",
+		"Thumbs.db",
+	];
+
+	async run(): Promise<void> {
+		await this.parse(LocalCleanup);
+
+		this.log(colorify.blue("🧹 Starting comprehensive cleanup..."));
+
+		this.log(colorify.yellow("🗂️ Cleaning development artifacts..."));
+		for (const directory of this.directories) {
+			await $`rm -rf ${directory} **/${directory} **/${directory}/**`.quiet().nothrow();
+		}
+
+		this.log(colorify.yellow("📝 Cleaning logs and temp files..."));
+		for (const file of this.files) {
+			await $`rm -rf ${file} **/${file}`.quiet().nothrow();
+		}
+
+		this.log(colorify.yellow("📦 Cleaning node_modules in directories..."));
+		await $`rm -rf node_modules **/node_modules`.quiet().nothrow();
+
+		this.log(colorify.yellow("🎯 Cleaning VS Code configuration..."));
+		await $`rm -rf .vscode`.quiet().nothrow();
+
+		this.log(colorify.green("✅ Cleanup completed successfully!"));
+		this.log(colorify.cyan("\n💡 To start fresh, run:"));
+		this.log(colorify.cyan("  - intershell local:setup # For local development"));
+		this.log(colorify.cyan("  - intershell dev:setup # For DevContainer development"));
+	}
+}

package/src/commands/local/setup.ts

@@ -0,0 +1,68 @@
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../../core";
+
+export default class LocalSetup extends Command {
+	static description =
+		"Complete local development environment setup with dependency installation, local builds, and VS Code configuration sync";
+
+	static examples = [
+		"intershell local:setup",
+		"intershell local:setup --skip-vscode",
+		"intershell local:setup --skip-tests",
+	];
+
+	static flags = {
+		"skip-vscode": Flags.boolean({
+			char: "v",
+			description: "Skip VS Code configuration sync",
+			default: false,
+		}),
+		"skip-tests": Flags.boolean({
+			char: "t",
+			description: "Skip running tests",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(LocalSetup);
+
+		this.log(colorify.blue("🚀 Starting local development setup..."));
+
+		// Step 1: Install dependencies
+		this.log(colorify.blue("📦 Installing dependencies..."));
+		await $`bun install`;
+
+		// Step 2: Run code quality checks
+		this.log(colorify.blue("🔍 Running code quality checks..."));
+		await $`bun run check:fix`;
+
+		// Step 3: Type checking
+		this.log(colorify.blue("🔍 Running type checks..."));
+		await $`bun run check:types`;
+
+		// Step 4: Run tests (unless skipped)
+		if (!flags["skip-tests"]) {
+			this.log(colorify.blue("🧪 Running tests..."));
+			await $`bun run test`;
+		}
+
+		// Step 5: Build all packages
+		this.log(colorify.blue("🏗️ Building all packages..."));
+		await $`bun run build`;
+
+		// Step 6: Sync VS Code configuration (unless skipped)
+		if (!flags["skip-vscode"]) {
+			this.log(colorify.blue("🎯 Syncing VS Code configuration..."));
+			await $`bun run local:vscode`;
+		}
+
+		this.log(colorify.green("✅ Local setup completed successfully!"));
+
+		this.log(colorify.cyan("\n💡 Useful commands:"));
+		this.log(colorify.cyan(" - bun run check:quick # Quick verification"));
+		this.log(colorify.cyan(" - intershell dev:setup # Setup DevContainer environment"));
+		this.log(colorify.cyan(" - intershell local:cleanup # Clean everything"));
+	}
+}

package/src/commands/local/vscode.ts

@@ -0,0 +1,118 @@
+import { exists, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { EntityPackage } from "../../entities";
+
+export default class LocalVscode extends Command {
+	static description =
+		"Synchronize VS Code extensions and settings from devcontainer.json to .vscode/ directory";
+
+	static examples = [
+		"intershell local:vscode",
+		"intershell local:vscode --dry-run",
+		"intershell local:vscode --extensions-only",
+		"intershell local:vscode --settings-only",
+		"intershell local:vscode --quiet",
+	];
+
+	static flags = {
+		"dry-run": Flags.boolean({
+			description: "Show what would be synced without making changes",
+			default: false,
+		}),
+		"extensions-only": Flags.boolean({
+			description: "Only sync extensions",
+			default: false,
+		}),
+		"settings-only": Flags.boolean({
+			description: "Only sync settings",
+			default: false,
+		}),
+		quiet: Flags.boolean({
+			description: "Suppress all output except errors",
+			default: false,
+		}),
+	};
+
+	/**
+	 * Log a message only if not in quiet mode
+	 */
+	private logQuiet(message: string, quiet: boolean): void {
+		if (!quiet) {
+			this.log(message);
+		}
+	}
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(LocalVscode);
+
+		this.logQuiet("🔄 Syncing VS Code configuration from devcontainer.json...", flags.quiet);
+
+		const scopes = await EntityPackage.getAllPackages();
+		this.logQuiet(`📋 Generated scopes: ${scopes.join(", ")}`, flags.quiet);
+
+		const {
+			customizations: { vscode: { extensions: recommendations = [], settings = {} } = {} } = {},
+		} = JSON.parse(
+			stripComments(
+				await Bun.file(join(process.cwd(), ".devcontainer", "devcontainer.json")).text(),
+			),
+		);
+
+		// Update settings with generated scopes
+		const updatedSettings = {
+			...settings,
+			"conventionalCommits.scopes": scopes,
+		};
+
+		const settingsConfigString = JSON.stringify(updatedSettings, null, 2);
+		const extensionsConfigString = JSON.stringify({ recommendations }, null, 2);
+
+		if (flags["dry-run"]) {
+			this.logQuiet("🔍 Dry run mode - showing what would be synced:", flags.quiet);
+			this.logQuiet(`📦 Extensions:\n${extensionsConfigString}`, flags.quiet);
+			this.logQuiet(`⚙️  Settings:\n${settingsConfigString}`, flags.quiet);
+			return;
+		}
+
+		// Update devcontainer.json with new scopes
+		const devcontainerPath = join(process.cwd(), ".devcontainer", "devcontainer.json");
+		const devcontainerContent = JSON.parse(stripComments(await Bun.file(devcontainerPath).text()));
+
+		// Update the scopes in devcontainer.json
+		devcontainerContent.customizations.vscode.settings["conventionalCommits.scopes"] = scopes;
+
+		// Write back the updated devcontainer.json
+		await Bun.write(devcontainerPath, JSON.stringify(devcontainerContent, null, 2));
+		await $`bun run biome check --write ${devcontainerPath}`;
+		this.logQuiet(`✅ Updated ${devcontainerPath} with new scopes!`, flags.quiet);
+
+		const vscodeDir = join(process.cwd(), ".vscode");
+		if (!(await exists(vscodeDir))) await mkdir(vscodeDir, { recursive: true });
+		const extensionsPath = join(vscodeDir, "extensions.json");
+		const settingsPath = join(vscodeDir, "settings.json");
+
+		if (!flags["settings-only"]) {
+			await Bun.write(extensionsPath, extensionsConfigString);
+			this.logQuiet(`✅ Updated ${extensionsPath}!`, flags.quiet);
+		}
+
+		if (!flags["extensions-only"]) {
+			await Bun.write(settingsPath, settingsConfigString);
+			this.logQuiet(`✅ Updated ${settingsPath}!`, flags.quiet);
+		}
+
+		this.logQuiet("✅ VS Code configuration synced successfully!", flags.quiet);
+	}
+}
+
+/**
+ * Strip comments from JSON content
+ */
+function stripComments(content: string): string {
+	return content
+		.replace(/\/\/[^\r\n]*/g, "")
+		.replace(/\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g, "")
+		.replace(/^\s*[\r\n]/gm, "");
+}

package/src/commands/update-package-json.ts

@@ -0,0 +1,104 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { Command, Flags } from "@oclif/core";
+import { $ } from "bun";
+import { colorify } from "../core";
+
+export default class UpdatePackageJson extends Command {
+	static description =
+		"Update the package.json exports attributes based on the files in the package";
+
+	static examples = ["intershell update-package-json"];
+
+	static flags = {
+		src: Flags.boolean({
+			char: "s",
+			description: "Are you using src directory? (default: true)",
+			default: true,
+		}),
+		"dry-run": Flags.boolean({
+			char: "d",
+			description: "Show what would be updated without making changes",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(UpdatePackageJson);
+		this.log(colorify.blue("🧹 Starting package.json update..."));
+
+		const packageJsonPath = path.join(process.cwd(), "package.json");
+		const packageDir = path.dirname(packageJsonPath);
+		const srcDir = flags.src ? path.join(packageDir, "src") : packageDir;
+		const files = await readdir(srcDir, {
+			withFileTypes: true,
+			recursive: false,
+		});
+
+		this.log(
+			colorify.blue(`🔍 Found ${files.length} exportable modules:`),
+			colorify.cyan(files.map((f) => f.name).join(" ")),
+		);
+
+		const newExports = await this.getNewExports(files, srcDir, packageDir);
+
+		if (flags["dry-run"]) {
+			this.log(colorify.yellow("🔍 Dry run mode, skipping write:"));
+			this.log(JSON.stringify(newExports, null, 2));
+			return;
+		}
+
+		const packageJson = JSON.parse(await Bun.file(packageJsonPath).text());
+		packageJson.exports = newExports;
+
+		await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
+		await $`bun biome check --write --no-errors-on-unmatched ${packageJsonPath}`;
+		this.log(colorify.green("✅ Package.json updated successfully"));
+	}
+
+	private async getNewExports(
+		files: Array<{ name: string; isDirectory(): boolean }>,
+		srcDir: string,
+		packageDir: string,
+	): Promise<Record<string, string>> {
+		const newExports: Record<string, string> = {};
+
+		for (const file of files) {
+			if (file.isDirectory()) {
+				const indexFile = path.join(srcDir, file.name, "index.ts");
+				const indexTsxFile = path.join(srcDir, file.name, "index.tsx");
+				const sameNameFile = path.join(srcDir, file.name, `${file.name}.ts`);
+				const sameNameTsxFile = path.join(srcDir, file.name, `${file.name}.tsx`);
+
+				if (await Bun.file(indexFile).exists()) {
+					newExports[`./${file.name}`] = `./${path.relative(packageDir, indexFile)}`;
+				} else if (await Bun.file(indexTsxFile).exists()) {
+					newExports[`./${file.name}`] = `./${path.relative(packageDir, indexTsxFile)}`;
+				} else if (await Bun.file(sameNameFile).exists()) {
+					newExports[`./${file.name}`] = `./${path.relative(packageDir, sameNameFile)}`;
+				} else if (await Bun.file(sameNameTsxFile).exists()) {
+					newExports[`./${file.name}`] = `./${path.relative(packageDir, sameNameTsxFile)}`;
+				}
+
+				continue;
+			}
+
+			const shouldSkip = !file.name.endsWith(".ts") && !file.name.endsWith(".tsx");
+			if (shouldSkip) continue;
+
+			if (file.name === "index.ts") {
+				newExports["."] = "./index.ts";
+				continue;
+			}
+
+			const mainFile = path.join(srcDir, file.name);
+			const relativePath = `./${path.relative(packageDir, mainFile)}`;
+
+			if (await Bun.file(mainFile).exists()) {
+				newExports[`./${file.name}`] = relativePath;
+			}
+		}
+
+		return newExports;
+	}
+}