@kuckit/cli 1.0.0 → 1.0.4

package/dist/discover-module-B4oRIuSK.js

@@ -0,0 +1,1019 @@
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+
+//#region src/commands/generate-module.ts
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+	return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+async function generateModule(name, options) {
+	const kebabName = toKebabCase(name);
+	const pascalName = toPascalCase(name);
+	const camelName = toCamelCase(name);
+	const moduleDirName = `${kebabName}-module`;
+	const packageName = options.org ? `@${options.org}/${moduleDirName}` : `@kuckit/${moduleDirName}`;
+	const moduleId = options.org ? `${options.org}.${kebabName}` : `kuckit.${kebabName}`;
+	const targetDir = join(process.cwd(), options.dir, moduleDirName);
+	console.log(`Creating module: ${packageName}`);
+	console.log(`  Directory: ${targetDir}`);
+	await mkdir(join(targetDir, "src", "domain"), { recursive: true });
+	await mkdir(join(targetDir, "src", "ports"), { recursive: true });
+	await mkdir(join(targetDir, "src", "adapters"), { recursive: true });
+	await mkdir(join(targetDir, "src", "usecases"), { recursive: true });
+	await mkdir(join(targetDir, "src", "api"), { recursive: true });
+	await mkdir(join(targetDir, "src", "ui"), { recursive: true });
+	const packageJson = {
+		name: packageName,
+		version: "0.1.0",
+		private: true,
+		description: `${pascalName} module for Kuckit`,
+		type: "module",
+		main: "src/index.ts",
+		types: "src/index.ts",
+		exports: {
+			".": {
+				types: "./src/index.ts",
+				default: "./src/index.ts"
+			},
+			"./client": {
+				types: "./src/client-module.ts",
+				default: "./src/client-module.ts"
+			},
+			"./ui": {
+				types: "./src/ui/index.ts",
+				default: "./src/ui/index.ts"
+			}
+		},
+		peerDependencies: { typescript: "^5" },
+		dependencies: {
+			"@kuckit/sdk": "^1.0.0",
+			"@kuckit/sdk-react": "^1.0.0",
+			"@kuckit/api": "^1.0.0",
+			"@orpc/server": "^1.10.0",
+			"@orpc/zod": "^1.10.0",
+			"drizzle-orm": "^0.44.0",
+			zod: "^3.23.0",
+			react: "^19.0.0",
+			"@tanstack/react-query": "^5.0.0"
+		}
+	};
+	await writeFile(join(targetDir, "package.json"), JSON.stringify(packageJson, null, "	") + "\n");
+	await writeFile(join(targetDir, "tsconfig.json"), JSON.stringify({
+		extends: "../../tsconfig.base.json",
+		compilerOptions: {
+			outDir: "dist",
+			rootDir: "src"
+		},
+		include: ["src"]
+	}, null, "	") + "\n");
+	const entityFile = `import { z } from 'zod'
+
+/**
+ * ${pascalName} entity schema
+ */
+export const ${pascalName}Schema = z.object({
+	id: z.string(),
+	name: z.string().min(1, 'Name is required'),
+	description: z.string().optional(),
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	userId: z.string(),
+})
+
+export type ${pascalName} = z.infer<typeof ${pascalName}Schema>
+
+/**
+ * Create ${camelName} input schema
+ */
+export const Create${pascalName}InputSchema = z.object({
+	name: z.string().min(1, 'Name is required'),
+	description: z.string().optional(),
+})
+
+export type Create${pascalName}Input = z.infer<typeof Create${pascalName}InputSchema>
+
+/**
+ * Update ${camelName} input schema
+ */
+export const Update${pascalName}InputSchema = z.object({
+	id: z.string(),
+	name: z.string().min(1, 'Name is required').optional(),
+	description: z.string().optional(),
+})
+
+export type Update${pascalName}Input = z.infer<typeof Update${pascalName}InputSchema>
+`;
+	await writeFile(join(targetDir, "src", "domain", `${kebabName}.entity.ts`), entityFile);
+	const repositoryPort = `import type { ${pascalName}, Create${pascalName}Input, Update${pascalName}Input } from '../domain/${kebabName}.entity'
+
+/**
+ * ${pascalName} repository port interface
+ * Defines the contract for ${camelName} persistence operations
+ */
+export interface ${pascalName}Repository {
+	findById(id: string): Promise<${pascalName} | null>
+	findByUserId(userId: string): Promise<${pascalName}[]>
+	create(input: Create${pascalName}Input & { id: string; userId: string }): Promise<${pascalName}>
+	update(input: Update${pascalName}Input): Promise<${pascalName} | null>
+	delete(id: string): Promise<boolean>
+}
+`;
+	await writeFile(join(targetDir, "src", "ports", `${kebabName}.repository.ts`), repositoryPort);
+	const drizzleAdapter = `import { pgTable, text, timestamp } from 'drizzle-orm/pg-core'
+import { eq } from 'drizzle-orm'
+import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+import type { ${pascalName}, Create${pascalName}Input, Update${pascalName}Input } from '../domain/${kebabName}.entity'
+
+/**
+ * ${pascalName}s table schema for Drizzle ORM
+ */
+export const ${camelName}sTable = pgTable('${kebabName}s', {
+	id: text('id').primaryKey(),
+	name: text('name').notNull(),
+	description: text('description'),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+	updatedAt: timestamp('updated_at').notNull().defaultNow(),
+	userId: text('user_id').notNull(),
+})
+
+/**
+ * Create a Drizzle-based ${camelName} repository
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function make${pascalName}Repository(db: any): ${pascalName}Repository {
+	return {
+		async findById(id: string): Promise<${pascalName} | null> {
+			const results = await db.select().from(${camelName}sTable).where(eq(${camelName}sTable.id, id))
+			return results[0] ?? null
+		},
+
+		async findByUserId(userId: string): Promise<${pascalName}[]> {
+			return db.select().from(${camelName}sTable).where(eq(${camelName}sTable.userId, userId))
+		},
+
+		async create(input: Create${pascalName}Input & { id: string; userId: string }): Promise<${pascalName}> {
+			const now = new Date()
+			const ${camelName} = {
+				id: input.id,
+				name: input.name,
+				description: input.description ?? null,
+				createdAt: now,
+				updatedAt: now,
+				userId: input.userId,
+			}
+			await db.insert(${camelName}sTable).values(${camelName})
+			return ${camelName} as ${pascalName}
+		},
+
+		async update(input: Update${pascalName}Input): Promise<${pascalName} | null> {
+			const existing = await this.findById(input.id)
+			if (!existing) return null
+
+			const updated = {
+				...existing,
+				...(input.name !== undefined && { name: input.name }),
+				...(input.description !== undefined && { description: input.description }),
+				updatedAt: new Date(),
+			}
+			await db.update(${camelName}sTable).set(updated).where(eq(${camelName}sTable.id, input.id))
+			return updated
+		},
+
+		async delete(id: string): Promise<boolean> {
+			const result = await db.delete(${camelName}sTable).where(eq(${camelName}sTable.id, id))
+			return result.rowCount > 0
+		},
+	}
+}
+`;
+	await writeFile(join(targetDir, "src", "adapters", `${kebabName}.drizzle.ts`), drizzleAdapter);
+	const listUseCase = `import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+import type { ${pascalName} } from '../domain/${kebabName}.entity'
+
+interface List${pascalName}sDeps {
+	${camelName}Repository: ${pascalName}Repository
+}
+
+/**
+ * List ${camelName}s use case
+ */
+export function makeList${pascalName}s(deps: List${pascalName}sDeps) {
+	return async (userId: string): Promise<${pascalName}[]> => {
+		return deps.${camelName}Repository.findByUserId(userId)
+	}
+}
+`;
+	await writeFile(join(targetDir, "src", "usecases", `list-${kebabName}s.ts`), listUseCase);
+	const getUseCase = `import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+import type { ${pascalName} } from '../domain/${kebabName}.entity'
+
+interface Get${pascalName}Deps {
+	${camelName}Repository: ${pascalName}Repository
+}
+
+/**
+ * Get ${camelName} use case
+ */
+export function makeGet${pascalName}(deps: Get${pascalName}Deps) {
+	return async (id: string): Promise<${pascalName} | null> => {
+		return deps.${camelName}Repository.findById(id)
+	}
+}
+`;
+	await writeFile(join(targetDir, "src", "usecases", `get-${kebabName}.ts`), getUseCase);
+	const createUseCase = `import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+import type { ${pascalName}, Create${pascalName}Input } from '../domain/${kebabName}.entity'
+
+export interface Create${pascalName}UseCaseInput extends Create${pascalName}Input {
+	userId: string
+}
+
+interface Create${pascalName}Deps {
+	${camelName}Repository: ${pascalName}Repository
+}
+
+/**
+ * Create ${camelName} use case
+ */
+export function makeCreate${pascalName}(deps: Create${pascalName}Deps) {
+	return async (input: Create${pascalName}UseCaseInput): Promise<${pascalName}> => {
+		const id = crypto.randomUUID()
+		return deps.${camelName}Repository.create({
+			id,
+			name: input.name,
+			description: input.description,
+			userId: input.userId,
+		})
+	}
+}
+`;
+	await writeFile(join(targetDir, "src", "usecases", `create-${kebabName}.ts`), createUseCase);
+	const deleteUseCase = `import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+
+interface Delete${pascalName}Deps {
+	${camelName}Repository: ${pascalName}Repository
+}
+
+/**
+ * Delete ${camelName} use case
+ */
+export function makeDelete${pascalName}(deps: Delete${pascalName}Deps) {
+	return async (id: string): Promise<boolean> => {
+		return deps.${camelName}Repository.delete(id)
+	}
+}
+`;
+	await writeFile(join(targetDir, "src", "usecases", `delete-${kebabName}.ts`), deleteUseCase);
+	const routerFile = `import { z } from 'zod'
+import { protectedProcedure } from '@kuckit/api'
+import { Create${pascalName}InputSchema } from '../domain/${kebabName}.entity'
+import type { ${pascalName}Repository } from '../ports/${kebabName}.repository'
+
+/**
+ * ${pascalName}s oRPC router
+ * Provides CRUD operations for ${camelName}s
+ */
+export const ${camelName}sRouter = {
+	list: protectedProcedure.input(z.object({})).handler(async ({ context }) => {
+		const userId = context.session?.user?.id
+		if (!userId) throw new Error('User not authenticated')
+
+		const ${camelName}s = await context.di.resolve<${pascalName}Repository>('${camelName}Repository').findByUserId(userId)
+		return ${camelName}s
+	}),
+
+	get: protectedProcedure
+		.input(z.object({ id: z.string() }))
+		.handler(async ({ input, context }) => {
+			const ${camelName} = await context.di.resolve<${pascalName}Repository>('${camelName}Repository').findById(input.id)
+			return ${camelName}
+		}),
+
+	create: protectedProcedure.input(Create${pascalName}InputSchema).handler(async ({ input, context }) => {
+		const userId = context.session?.user?.id
+		if (!userId) throw new Error('User not authenticated')
+
+		const id = crypto.randomUUID()
+		const ${camelName} = await context.di.resolve<${pascalName}Repository>('${camelName}Repository').create({
+			id,
+			name: input.name,
+			description: input.description,
+			userId,
+		})
+		return ${camelName}
+	}),
+
+	delete: protectedProcedure
+		.input(z.object({ id: z.string() }))
+		.handler(async ({ input, context }) => {
+			const success = await context.di.resolve<${pascalName}Repository>('${camelName}Repository').delete(input.id)
+			return { success }
+		}),
+}
+`;
+	await writeFile(join(targetDir, "src", "api", `${kebabName}s.router.ts`), routerFile);
+	const pageComponent = `import { useState } from 'react'
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { useRpc } from '@kuckit/sdk-react'
+
+interface ${pascalName} {
+	id: string
+	name: string
+	description?: string
+	createdAt: Date
+	updatedAt: Date
+}
+
+interface ${pascalName}sRpc {
+	${camelName}s: {
+		list: (input: Record<string, never>) => Promise<${pascalName}[]>
+		create: (input: { name: string; description?: string }) => Promise<${pascalName}>
+		delete: (input: { id: string }) => Promise<void>
+	}
+}
+
+/**
+ * ${pascalName}s page component
+ * Demonstrates CRUD operations using the ${camelName}s module with useRpc and TanStack Query
+ */
+export function ${pascalName}sPage() {
+	const rpc = useRpc<${pascalName}sRpc>()
+	const queryClient = useQueryClient()
+	const [newName, setNewName] = useState('')
+	const [newDescription, setNewDescription] = useState('')
+
+	const {
+		data: ${camelName}s = [],
+		isLoading,
+		error,
+	} = useQuery({
+		queryKey: ['${camelName}s'],
+		queryFn: () => rpc.${camelName}s.list({}),
+	})
+
+	const createMutation = useMutation({
+		mutationFn: (data: { name: string; description?: string }) => rpc.${camelName}s.create(data),
+		onSuccess: () => queryClient.invalidateQueries({ queryKey: ['${camelName}s'] }),
+	})
+
+	const deleteMutation = useMutation({
+		mutationFn: (id: string) => rpc.${camelName}s.delete({ id }),
+		onSuccess: () => queryClient.invalidateQueries({ queryKey: ['${camelName}s'] }),
+	})
+
+	const create${pascalName} = async (e: React.FormEvent) => {
+		e.preventDefault()
+		if (!newName.trim()) return
+
+		createMutation.mutate(
+			{ name: newName, description: newDescription || undefined },
+			{
+				onSuccess: () => {
+					setNewName('')
+					setNewDescription('')
+				},
+			}
+		)
+	}
+
+	const delete${pascalName} = (id: string) => {
+		deleteMutation.mutate(id)
+	}
+
+	if (isLoading) {
+		return <div style={{ padding: '2rem' }}>Loading ${camelName}s...</div>
+	}
+
+	return (
+		<div style={{ padding: '2rem', fontFamily: 'system-ui', maxWidth: '600px', margin: '0 auto' }}>
+			<h1>${pascalName}s</h1>
+
+			{(error || createMutation.error || deleteMutation.error) && (
+				<div style={{ color: 'red', marginBottom: '1rem' }}>
+					{error?.message || createMutation.error?.message || deleteMutation.error?.message}
+				</div>
+			)}
+
+			<form onSubmit={create${pascalName}} style={{ marginBottom: '2rem' }}>
+				<div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
+					<input
+						type="text"
+						placeholder="Name"
+						value={newName}
+						onChange={(e) => setNewName(e.target.value)}
+						required
+						style={{ padding: '0.5rem', fontSize: '1rem' }}
+					/>
+					<input
+						type="text"
+						placeholder="Description (optional)"
+						value={newDescription}
+						onChange={(e) => setNewDescription(e.target.value)}
+						style={{ padding: '0.5rem', fontSize: '1rem' }}
+					/>
+					<button
+						type="submit"
+						disabled={createMutation.isPending}
+						style={{ padding: '0.5rem 1rem', cursor: 'pointer' }}
+					>
+						{createMutation.isPending ? 'Adding...' : 'Add ${pascalName}'}
+					</button>
+				</div>
+			</form>
+
+			<ul style={{ listStyle: 'none', padding: 0 }}>
+				{${camelName}s.map((${camelName}) => (
+					<li
+						key={${camelName}.id}
+						style={{
+							padding: '1rem',
+							border: '1px solid #ccc',
+							marginBottom: '0.5rem',
+							borderRadius: '4px',
+							display: 'flex',
+							justifyContent: 'space-between',
+							alignItems: 'center',
+						}}
+					>
+						<div>
+							<strong>{${camelName}.name}</strong>
+							{${camelName}.description && (
+								<p style={{ margin: '0.5rem 0 0 0', color: '#666' }}>{${camelName}.description}</p>
+							)}
+						</div>
+						<button
+							onClick={() => delete${pascalName}(${camelName}.id)}
+							disabled={deleteMutation.isPending}
+							style={{ cursor: 'pointer', color: 'red', background: 'none', border: 'none' }}
+						>
+							Delete
+						</button>
+					</li>
+				))}
+			</ul>
+
+			{${camelName}s.length === 0 && <p>No ${camelName}s yet. Create one above!</p>}
+		</div>
+	)
+}
+`;
+	await writeFile(join(targetDir, "src", "ui", `${pascalName}sPage.tsx`), pageComponent);
+	const uiIndex = `export { ${pascalName}sPage } from './${pascalName}sPage'
+`;
+	await writeFile(join(targetDir, "src", "ui", "index.ts"), uiIndex);
+	const serverModule = `import { defineKuckitModule, asFunction, type KuckitModuleContext } from '@kuckit/sdk'
+import { ${camelName}sTable, make${pascalName}Repository } from './adapters/${kebabName}.drizzle'
+import { ${camelName}sRouter } from './api/${kebabName}s.router'
+
+export type ${pascalName}ModuleConfig = Record<string, never>
+
+/**
+ * ${pascalName} module - Kuckit module demonstrating Clean Architecture pattern
+ *
+ * This module shows:
+ * - Domain entity with Zod validation
+ * - Repository port/adapter pattern
+ * - Use cases for business logic
+ * - oRPC router for API endpoints
+ */
+export const kuckitModule = defineKuckitModule<${pascalName}ModuleConfig>({
+	id: '${moduleId}',
+	displayName: '${pascalName}',
+	description: '${pascalName} module for CRUD operations',
+	version: '0.1.0',
+
+	async register(ctx: KuckitModuleContext<${pascalName}ModuleConfig>) {
+		const { container } = ctx
+
+		// Register schema for migrations
+		ctx.registerSchema('${camelName}s', ${camelName}sTable)
+
+		// Register repository
+		container.register({
+			${camelName}Repository: asFunction(({ db }) => make${pascalName}Repository(db)).scoped(),
+		})
+	},
+
+	registerApi(ctx) {
+		ctx.addApiRegistration({
+			type: 'rpc-router',
+			name: '${camelName}s',
+			router: ${camelName}sRouter,
+		})
+	},
+
+	async onBootstrap(ctx: KuckitModuleContext<${pascalName}ModuleConfig>) {
+		const { container } = ctx
+		const logger = container.resolve('logger')
+		logger.info('${pascalName} module initialized')
+	},
+
+	async onShutdown(ctx: KuckitModuleContext<${pascalName}ModuleConfig>) {
+		const { container } = ctx
+		const logger = container.resolve('logger')
+		logger.info('${pascalName} module shutting down')
+	},
+})
+`;
+	await writeFile(join(targetDir, "src", "module.ts"), serverModule);
+	const clientModule = `import { defineKuckitClientModule, type KuckitClientModuleContext } from '@kuckit/sdk-react'
+import { ${pascalName}sPage } from './ui/${pascalName}sPage'
+
+/**
+ * ${pascalName} client module
+ * Registers routes and components for the web app
+ */
+export const kuckitClientModule = defineKuckitClientModule({
+	id: '${moduleId}',
+	displayName: '${pascalName}',
+	version: '0.1.0',
+
+	register(ctx: KuckitClientModuleContext) {
+		// Register the ${camelName}s page component
+		ctx.registerComponent('${pascalName}sPage', ${pascalName}sPage)
+
+		// Add route for ${camelName}s page
+		ctx.addRoute({
+			id: '${kebabName}s',
+			path: '/${kebabName}s',
+			component: ${pascalName}sPage,
+			meta: {
+				title: '${pascalName}s',
+				requiresAuth: true,
+			},
+		})
+
+		// Add navigation item
+		ctx.addNavItem({
+			id: '${kebabName}s-nav',
+			label: '${pascalName}s',
+			path: '/${kebabName}s',
+			icon: 'list',
+			order: 100,
+		})
+	},
+})
+
+export { ${pascalName}sPage } from './ui/${pascalName}sPage'
+`;
+	await writeFile(join(targetDir, "src", "client-module.ts"), clientModule);
+	const indexFile = `// Server module
+export { kuckitModule } from './module'
+
+// Domain
+export * from './domain/${kebabName}.entity'
+
+// Ports
+export type { ${pascalName}Repository } from './ports/${kebabName}.repository'
+
+// Adapters
+export { ${camelName}sTable, make${pascalName}Repository } from './adapters/${kebabName}.drizzle'
+
+// Use cases
+export { makeList${pascalName}s } from './usecases/list-${kebabName}s'
+export { makeGet${pascalName} } from './usecases/get-${kebabName}'
+export { makeCreate${pascalName} } from './usecases/create-${kebabName}'
+export { makeDelete${pascalName} } from './usecases/delete-${kebabName}'
+
+// API
+export { ${camelName}sRouter } from './api/${kebabName}s.router'
+`;
+	await writeFile(join(targetDir, "src", "index.ts"), indexFile);
+	console.log(`
+✅ Module created successfully!
+
+📁 Structure:
+  ${options.dir}/${moduleDirName}/
+  ├── src/
+  │   ├── domain/
+  │   │   └── ${kebabName}.entity.ts       # Zod schema for entity
+  │   ├── ports/
+  │   │   └── ${kebabName}.repository.ts   # Repository interface
+  │   ├── adapters/
+  │   │   └── ${kebabName}.drizzle.ts      # Drizzle implementation
+  │   ├── usecases/
+  │   │   ├── list-${kebabName}s.ts
+  │   │   ├── get-${kebabName}.ts
+  │   │   ├── create-${kebabName}.ts
+  │   │   └── delete-${kebabName}.ts
+  │   ├── api/
+  │   │   └── ${kebabName}s.router.ts      # oRPC router
+  │   ├── ui/
+  │   │   └── ${pascalName}sPage.tsx       # React component
+  │   ├── module.ts                        # Server module
+  │   ├── client-module.ts                 # Client module
+  │   └── index.ts
+  ├── package.json
+  └── tsconfig.json
+
+📝 Next steps:
+  1. Run 'bun install' from the root to link the new package
+  2. Add module to apps/server/src/config/modules.ts:
+     import { kuckitModule as ${camelName}Module } from '${packageName}'
+     export const modules = [..., ${camelName}Module]
+  3. Add client module to apps/web/src/modules.client.ts:
+     import { kuckitClientModule as ${camelName}Client } from '${packageName}/client'
+     export const clientModules = [..., { module: ${camelName}Client }]
+  4. Add schema path to packages/db/drizzle.config.ts:
+     schema: [..., '../${moduleDirName}/src/adapters/${kebabName}.drizzle.ts']
+  5. Run 'bun run db:push' to create the table
+`);
+}
+
+//#endregion
+//#region src/commands/add-module.ts
+const CONFIG_FILES = [
+	"kuckit.config.ts",
+	"kuckit.config.js",
+	"kuckit.config.mjs"
+];
+async function fileExists(path) {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function findConfigFile(cwd) {
+	for (const file of CONFIG_FILES) {
+		const configPath = join(cwd, file);
+		if (existsSync(configPath)) return configPath;
+	}
+	return null;
+}
+function detectPackageManager(cwd) {
+	for (const [file, pm] of Object.entries({
+		"bun.lock": "bun",
+		"bun.lockb": "bun",
+		"package-lock.json": "npm",
+		"yarn.lock": "yarn",
+		"pnpm-lock.yaml": "pnpm"
+	})) try {
+		accessSync(join(cwd, file), constants.F_OK);
+		return pm;
+	} catch {}
+	return "npm";
+}
+async function readPackageKuckitMetadata(packageName, cwd) {
+	const packageJsonPath = join(cwd, "node_modules", packageName, "package.json");
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		return JSON.parse(content).kuckit ?? null;
+	} catch {
+		return null;
+	}
+}
+const MODULES_MARKER_START = "// KUCKIT_MODULES_START";
+const MODULES_MARKER_END = "// KUCKIT_MODULES_END";
+const CLIENT_MODULES_MARKER_START = "// KUCKIT_CLIENT_MODULES_START";
+const CLIENT_MODULES_MARKER_END = "// KUCKIT_CLIENT_MODULES_END";
+/**
+* Add module to unified kuckit.config.ts
+*/
+async function addToUnifiedConfig(packageName, configPath) {
+	let content = await readFile(configPath, "utf-8");
+	if (content.includes(`'${packageName}'`) || content.includes(`"${packageName}"`)) {
+		console.log(`  Module ${packageName} is already in ${configPath}`);
+		return true;
+	}
+	const modulesArrayMatch = content.match(/modules:\s*\[/);
+	if (!modulesArrayMatch) {
+		console.warn(`Warning: Could not find 'modules' array in ${configPath}`);
+		console.log(`  Please manually add: { package: '${packageName}' }`);
+		return false;
+	}
+	const insertPos = modulesArrayMatch.index + modulesArrayMatch[0].length;
+	const newEntry = `\n\t\t{ package: '${packageName}' },`;
+	content = content.slice(0, insertPos) + newEntry + content.slice(insertPos);
+	await writeFile(configPath, content);
+	console.log(`  Added to unified config: ${configPath}`);
+	return true;
+}
+async function addToServerModules(packageName, cwd) {
+	const modulesPath = join(cwd, "apps", "server", "src", "config", "modules.ts");
+	if (!await fileExists(modulesPath)) {
+		console.warn(`Warning: Server modules file not found at ${modulesPath}`);
+		return false;
+	}
+	let content = await readFile(modulesPath, "utf-8");
+	if (content.includes(`package: '${packageName}'`)) {
+		console.log(`  Module ${packageName} is already in server modules`);
+		return true;
+	}
+	if (!content.includes(MODULES_MARKER_START)) {
+		if (content.match(/return modules\s*$/)) {
+			const insertPos = content.lastIndexOf("return modules");
+			const before$1 = content.slice(0, insertPos);
+			const after$1 = content.slice(insertPos);
+			content = before$1 + `\n\t\t${MODULES_MARKER_START}\n\t\t// Modules installed via 'kuckit add' will be added here\n\t\t${MODULES_MARKER_END}\n\n\t\t` + after$1;
+		}
+	}
+	const newEntry = `{ package: '${packageName}' },`;
+	const markerEndPos = content.indexOf(MODULES_MARKER_END);
+	if (markerEndPos === -1) {
+		console.warn(`Warning: Could not find marker in ${modulesPath}`);
+		console.log(`  Please manually add: ${newEntry}`);
+		return false;
+	}
+	const before = content.slice(0, markerEndPos);
+	const after = content.slice(markerEndPos);
+	content = before + `${newEntry}\n\t\t` + after;
+	await writeFile(modulesPath, content);
+	console.log(`  Added to server modules: ${modulesPath}`);
+	return true;
+}
+async function addToClientModules(packageName, clientPath, cwd) {
+	const clientModulesPath = join(cwd, "apps", "web", "src", "modules.client.ts");
+	if (!await fileExists(clientModulesPath)) {
+		await writeFile(clientModulesPath, `import type { ClientModuleSpec } from '@kuckit/sdk-react'
+
+/**
+ * Client module specifications
+ *
+ * Add your Kuckit client modules here. Modules can be:
+ * - Direct references: { module: myModule }
+ * - Package imports: { package: '@acme/billing-module/client' }
+ *
+ * The CLI command \`kuckit add <package>\` will automatically update this file.
+ */
+export const getClientModuleSpecs = (): ClientModuleSpec[] => [
+	${CLIENT_MODULES_MARKER_START}
+	${CLIENT_MODULES_MARKER_END}
+]
+`);
+		console.log(`  Created client modules file: ${clientModulesPath}`);
+	}
+	let content = await readFile(clientModulesPath, "utf-8");
+	const clientPackagePath = `${packageName}/${clientPath.replace("./", "")}`;
+	if (content.includes(`package: '${clientPackagePath}'`)) {
+		console.log(`  Client module is already registered`);
+		return true;
+	}
+	const newEntry = `{ package: '${clientPackagePath}' },`;
+	const markerEndPos = content.indexOf(CLIENT_MODULES_MARKER_END);
+	if (markerEndPos === -1) {
+		console.warn(`Warning: Could not find marker in ${clientModulesPath}`);
+		console.log(`  Please manually add: ${newEntry}`);
+		return false;
+	}
+	const before = content.slice(0, markerEndPos);
+	const after = content.slice(markerEndPos);
+	content = before + `${newEntry}\n\t` + after;
+	await writeFile(clientModulesPath, content);
+	console.log(`  Added to client modules: ${clientModulesPath}`);
+	return true;
+}
+async function addModule(packageName, options) {
+	const cwd = process.cwd();
+	console.log(`Adding module: ${packageName}`);
+	if (!options.skipInstall) {
+		const pm = detectPackageManager(cwd);
+		const installCmd = pm === "npm" ? `${pm} install ${packageName}` : `${pm} add ${packageName}`;
+		console.log(`  Installing with ${pm}...`);
+		try {
+			execSync(installCmd, {
+				cwd,
+				stdio: "inherit"
+			});
+		} catch {
+			console.error(`Failed to install ${packageName}`);
+			process.exit(1);
+		}
+	}
+	const metadata = await readPackageKuckitMetadata(packageName, cwd);
+	if (!metadata) {
+		console.error(`\nError: ${packageName} is not a valid Kuckit module.`);
+		console.error(`The package.json must contain a "kuckit" field with module metadata.`);
+		console.error(`\nExpected structure:`);
+		console.error(`{
+  "kuckit": {
+    "id": "acme.billing",
+    "server": ".",
+    "client": "./client"
+  }
+}`);
+		process.exit(1);
+	}
+	console.log(`  Found Kuckit module: ${metadata.id}`);
+	const configPath = findConfigFile(cwd);
+	if (configPath) await addToUnifiedConfig(packageName, configPath);
+	else {
+		if (metadata.server) await addToServerModules(packageName, cwd);
+		if (metadata.client) await addToClientModules(packageName, metadata.client, cwd);
+	}
+	console.log(`
+Module ${packageName} added successfully!
+
+Run 'bun run dev' to start the server with the new module.
+`);
+}
+
+//#endregion
+//#region src/lib/sdk-loader.ts
+async function loadTryLoadKuckitConfig() {
+	try {
+		const sdk = await import("@kuckit/sdk");
+		if (!sdk.tryLoadKuckitConfig) throw new Error("Invalid @kuckit/sdk version: tryLoadKuckitConfig not found.");
+		return sdk.tryLoadKuckitConfig;
+	} catch {
+		console.error("Error: This command requires @kuckit/sdk to be installed in your project.");
+		console.error("Install it with one of:");
+		console.error("  npm install -D @kuckit/sdk");
+		console.error("  pnpm add -D @kuckit/sdk");
+		console.error("  bun add -d @kuckit/sdk");
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/discover-module.ts
+async function readKuckitMetadataFromPath(packageJsonPath) {
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		return JSON.parse(content).kuckit ?? null;
+	} catch {
+		return null;
+	}
+}
+async function readPackageName(packageJsonPath) {
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		return JSON.parse(content).name ?? null;
+	} catch {
+		return null;
+	}
+}
+async function scanWorkspacePackages(cwd) {
+	const discovered = [];
+	const packagesDir = join(cwd, "packages");
+	if (!existsSync(packagesDir)) return discovered;
+	try {
+		const entries = await readdir(packagesDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const packageJsonPath = join(packagesDir, entry.name, "package.json");
+			const metadata = await readKuckitMetadataFromPath(packageJsonPath);
+			if (metadata) {
+				const packageName = await readPackageName(packageJsonPath);
+				if (packageName) discovered.push({
+					package: packageName,
+					id: metadata.id,
+					server: metadata.server,
+					client: metadata.client,
+					enabled: false,
+					local: true
+				});
+			}
+		}
+	} catch {}
+	return discovered;
+}
+async function scanNodeModules(cwd) {
+	const nodeModulesPath = join(cwd, "node_modules");
+	const discovered = [];
+	try {
+		const entries = await readdir(nodeModulesPath, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+			if (entry.name.startsWith(".")) continue;
+			if (entry.name.startsWith("@")) {
+				const scopePath = join(nodeModulesPath, entry.name);
+				try {
+					const scopedEntries = await readdir(scopePath, { withFileTypes: true });
+					for (const scopedEntry of scopedEntries) {
+						if (!scopedEntry.isDirectory() && !scopedEntry.isSymbolicLink()) continue;
+						const packageName = `${entry.name}/${scopedEntry.name}`;
+						const metadata = await readKuckitMetadataFromPath(join(nodeModulesPath, packageName, "package.json"));
+						if (metadata) discovered.push({
+							package: packageName,
+							id: metadata.id,
+							server: metadata.server,
+							client: metadata.client,
+							enabled: false
+						});
+					}
+				} catch {}
+			} else {
+				const metadata = await readKuckitMetadataFromPath(join(nodeModulesPath, entry.name, "package.json"));
+				if (metadata) discovered.push({
+					package: entry.name,
+					id: metadata.id,
+					server: metadata.server,
+					client: metadata.client,
+					enabled: false
+				});
+			}
+		}
+	} catch {}
+	return discovered;
+}
+async function addModulesToConfig(packages, configPath) {
+	const content = await readFile(configPath, "utf-8");
+	let updated = content;
+	for (const pkg of packages) {
+		if (updated.includes(`'${pkg}'`) || updated.includes(`"${pkg}"`)) continue;
+		const modulesArrayMatch = updated.match(/modules:\s*\[/);
+		if (!modulesArrayMatch) continue;
+		const insertPos = modulesArrayMatch.index + modulesArrayMatch[0].length;
+		const newEntry = `\n\t\t{ package: '${pkg}' },`;
+		updated = updated.slice(0, insertPos) + newEntry + updated.slice(insertPos);
+	}
+	if (updated !== content) {
+		const { writeFile: writeFile$1 } = await import("node:fs/promises");
+		await writeFile$1(configPath, updated);
+	}
+}
+async function discoverModules(options) {
+	const cwd = process.cwd();
+	if (!options.json) console.log("Scanning for Kuckit modules...\n");
+	const config = await (await loadTryLoadKuckitConfig())(cwd);
+	const configuredPackages = new Set(config?.modules.map((m) => m.package) ?? []);
+	const workspaceModules = await scanWorkspacePackages(cwd);
+	const nodeModules = await scanNodeModules(cwd);
+	const seen = /* @__PURE__ */ new Set();
+	const discovered = [];
+	for (const mod of workspaceModules) {
+		seen.add(mod.package);
+		mod.enabled = configuredPackages.has(mod.package);
+		discovered.push(mod);
+	}
+	for (const mod of nodeModules) if (!seen.has(mod.package)) {
+		mod.enabled = configuredPackages.has(mod.package);
+		discovered.push(mod);
+	}
+	discovered.sort((a, b) => {
+		if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+		return a.package.localeCompare(b.package);
+	});
+	const result = {
+		discovered,
+		enabled: discovered.filter((m) => m.enabled).length,
+		unconfigured: discovered.filter((m) => !m.enabled).length
+	};
+	if (options.json) {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	if (discovered.length === 0) {
+		console.log("No Kuckit modules found.");
+		console.log("\nInstall modules with: kuckit add <package>");
+		return;
+	}
+	console.log(`Found ${discovered.length} Kuckit module${discovered.length === 1 ? "" : "s"}:`);
+	for (const mod of discovered) {
+		const status = mod.enabled ? "✓" : "○";
+		const label = mod.enabled ? "(enabled)" : "(not configured)";
+		const localLabel = mod.local ? " [local]" : "";
+		console.log(`  ${status} ${mod.package}${localLabel} ${label}`);
+	}
+	const unconfigured = discovered.filter((m) => !m.enabled);
+	if (unconfigured.length === 0) {
+		console.log("\nAll discovered modules are already configured.");
+		return;
+	}
+	if (!options.interactive) {
+		console.log(`\n${unconfigured.length} module${unconfigured.length === 1 ? "" : "s"} not configured.`);
+		console.log("Run without --no-interactive to enable them.");
+		return;
+	}
+	if (!config?._configPath) {
+		console.log("\nNo kuckit.config.ts found. Create one first with:");
+		console.log("  npx create-kuckit-app --init");
+		return;
+	}
+	try {
+		const { checkbox } = await import("@inquirer/prompts");
+		const selected = await checkbox({
+			message: "Enable modules:",
+			choices: unconfigured.map((m) => ({
+				name: m.package,
+				value: m.package,
+				checked: true
+			}))
+		});
+		if (selected.length === 0) {
+			console.log("\nNo modules selected.");
+			return;
+		}
+		await addModulesToConfig(selected, config._configPath);
+		console.log(`\nUpdated kuckit.config.ts with ${selected.length} new module${selected.length === 1 ? "" : "s"}.`);
+	} catch (error) {
+		if (error.name === "ExitPromptError") {
+			console.log("\nCancelled.");
+			return;
+		}
+		throw error;
+	}
+}
+
+//#endregion
+export { generateModule as i, loadTryLoadKuckitConfig as n, addModule as r, discoverModules as t };