@kuckit/cli 1.0.0 → 1.0.4

package/dist/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { i as generateModule, n as loadTryLoadKuckitConfig, r as addModule, t as discoverModules } from "./discover-module-B7rxN4vq.js";
+import { i as generateModule, n as loadTryLoadKuckitConfig, r as addModule, t as discoverModules } from "./discover-module-B4oRIuSK.js";
 import { program } from "commander";
 import { dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { execSync, spawn } from "child_process";
 import { access, constants as constants$1, mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { dirname as dirname$1, join as join$1 } from "path";
@@ -15,6 +15,15 @@ const CONFIG_FILES = [
 	"kuckit.config.js",
 	"kuckit.config.mjs"
 ];
+const FRAMEWORK_PACKAGES = [
+	"@kuckit/sdk",
+	"@kuckit/sdk-react",
+	"@kuckit/api",
+	"@kuckit/db",
+	"@kuckit/auth",
+	"@kuckit/domain",
+	"@kuckit/contracts"
+];
 function findConfigFile(cwd) {
 	let dir = cwd;
 	while (dir !== dirname(dir)) {
@@ -58,6 +67,18 @@ function findPackagePath(packageName, cwd) {
 	}
 	return null;
 }
+function scanSourceFiles(dir) {
+	const files = [];
+	try {
+		const entries = readdirSync(dir);
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			if (statSync(fullPath).isDirectory()) files.push(...scanSourceFiles(fullPath));
+			else if (entry.endsWith(".ts") || entry.endsWith(".tsx")) files.push(fullPath);
+		}
+	} catch {}
+	return files;
+}
 function checkModuleExports(packageName, cwd) {
 	const result = {
 		server: false,
@@ -211,19 +232,114 @@ async function doctor(options) {
 		status: "pass",
 		message: "Module exports valid"
 	});
-	const sdkPackages = ["@kuckit/sdk", "@kuckit/sdk-react"];
-	const missingSdk = [];
-	for (const sdk of sdkPackages) if (!readPackageJson(sdk, cwd)) missingSdk.push(sdk);
-	if (missingSdk.length > 0) checks.push({
-		name: "sdk-installed",
+	const missingFramework = [];
+	const installedFramework = [];
+	for (const pkg of FRAMEWORK_PACKAGES) {
+		const pkgJson = readPackageJson(pkg, cwd);
+		if (!pkgJson) missingFramework.push(pkg);
+		else installedFramework.push({
+			name: pkg,
+			version: pkgJson.version
+		});
+	}
+	if (missingFramework.length > 0) checks.push({
+		name: "framework-installed",
 		status: "warn",
-		message: `SDK package(s) not found: ${missingSdk.join(", ")}`
+		message: `Framework package(s) not found: ${missingFramework.length}/${FRAMEWORK_PACKAGES.length}`,
+		details: missingFramework.map((p) => `  - ${p} (not installed)`)
 	});
 	else checks.push({
-		name: "sdk-installed",
+		name: "framework-installed",
+		status: "pass",
+		message: `All ${FRAMEWORK_PACKAGES.length} framework packages installed`
+	});
+	const kuckitVersions = /* @__PURE__ */ new Map();
+	for (const { name, version } of installedFramework) if (version) kuckitVersions.set(name, version);
+	const uniqueVersions = new Set(kuckitVersions.values());
+	if (uniqueVersions.size > 1 && installedFramework.length >= 2) {
+		const versionParts = [...uniqueVersions].map((v) => {
+			const match = v.match(/^(\d+)\.(\d+)/);
+			return match ? `${match[1]}.${match[2]}` : v;
+		});
+		if (new Set(versionParts).size > 1) checks.push({
+			name: "version-compatibility",
+			status: "warn",
+			message: "Framework packages have mismatched versions",
+			details: [...kuckitVersions.entries()].map(([name, ver]) => `  - ${name}: ${ver}`)
+		});
+		else checks.push({
+			name: "version-compatibility",
+			status: "pass",
+			message: "Framework package versions are compatible"
+		});
+	} else if (installedFramework.length >= 2) checks.push({
+		name: "version-compatibility",
 		status: "pass",
-		message: "SDK packages installed"
+		message: "Framework package versions are compatible"
 	});
+	const localImportIssues = [];
+	for (const packageName of installedPackages) {
+		const packagePath = findPackagePath(packageName, cwd);
+		if (!packagePath) continue;
+		const srcPath = join(packagePath, "src");
+		if (!existsSync(srcPath)) continue;
+		try {
+			const files = scanSourceFiles(srcPath);
+			for (const file of files) if (readFileSync(file, "utf-8").match(/from\s+['"]@(?!kuckit\/)[^'"/]+\/(api|db|auth|domain|contracts)['"]/g)) {
+				const relPath = file.replace(cwd, ".");
+				localImportIssues.push(`${packageName}: ${relPath} imports from local package instead of @kuckit/*`);
+			}
+		} catch {}
+	}
+	if (localImportIssues.length > 0) checks.push({
+		name: "framework-imports",
+		status: "warn",
+		message: `${localImportIssues.length} module(s) import from local packages instead of @kuckit/*`,
+		details: localImportIssues.slice(0, 5).map((i) => `  - ${i}`)
+	});
+	else if (installedPackages.length > 0) checks.push({
+		name: "framework-imports",
+		status: "pass",
+		message: "Module imports use @kuckit/* framework packages"
+	});
+	const serverModulesPath = join(cwd, "apps", "server", "src", "config", "modules.ts");
+	const clientModulesPath = join(cwd, "apps", "web", "src", "modules.client.ts");
+	if (existsSync(serverModulesPath) && existsSync(clientModulesPath)) {
+		const serverContent = readFileSync(serverModulesPath, "utf-8");
+		const clientContent = readFileSync(clientModulesPath, "utf-8");
+		const serverModulePattern = /from\s+['"]@[^'"]+\/([^'"]+)-module['"]/g;
+		const clientModulePattern = /from\s+['"]@[^'"]+\/([^'"]+)-module\/client['"]/g;
+		const serverModules = /* @__PURE__ */ new Set();
+		const clientModules = /* @__PURE__ */ new Set();
+		let match;
+		while ((match = serverModulePattern.exec(serverContent)) !== null) {
+			const lineStart = serverContent.lastIndexOf("\n", match.index) + 1;
+			if (!serverContent.slice(lineStart, match.index).includes("//")) serverModules.add(match[1]);
+		}
+		while ((match = clientModulePattern.exec(clientContent)) !== null) {
+			const lineStart = clientContent.lastIndexOf("\n", match.index) + 1;
+			if (!clientContent.slice(lineStart, match.index).includes("//")) clientModules.add(match[1]);
+		}
+		const clientOnly = [...clientModules].filter((m) => !serverModules.has(m));
+		const serverOnly = [...serverModules].filter((m) => !clientModules.has(m));
+		if (clientOnly.length > 0) checks.push({
+			name: "module-sync",
+			status: "fail",
+			message: `Client modules without matching server modules (will cause 404 errors)`,
+			details: clientOnly.map((m) => `  - ${m}-module: registered in client but not server`)
+		});
+		else if (serverOnly.length > 0) checks.push({
+			name: "module-sync",
+			status: "warn",
+			message: `Server modules without matching client modules`,
+			details: serverOnly.map((m) => `  - ${m}-module: registered in server but not client`)
+		});
+		else if (serverModules.size > 0 || clientModules.size > 0) checks.push({
+			name: "module-sync",
+			status: "pass",
+			message: "Server and client modules are in sync"
+		});
+	}
 	const report = {
 		success: checks.every((c) => c.status !== "fail"),
 		checks,
@@ -519,7 +635,7 @@ async function dbStudio(options) {
 
 //#endregion
 //#region src/lib/credentials.ts
-const DEFAULT_SERVER_URL = "http://localhost:3000";
+const DEFAULT_SERVER_URL = "https://dev-app-nyh7i73bea-uc.a.run.app/";
 const CONFIG_DIR = join(homedir(), ".kuckit");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 function loadConfig$8() {
@@ -1551,6 +1667,7 @@ async function infraDeploy(options) {
 	}
 	console.log("Configuring deployment...");
 	await setPulumiConfig("imageUrl", imageUrl, { cwd: infraDir });
+	if (config.outputs?.serviceUrl) await setPulumiConfig("appUrl", config.outputs.serviceUrl, { cwd: infraDir });
 	if (options.preview) console.log("\nPreviewing changes...\n");
 	else console.log("\nDeploying to Cloud Run...\n");
 	const result = await pulumiUp({