@vira-ui/cli 1.0.1 → 1.0.2

package/dist/index.js

@@ -91,8 +91,79 @@ const program = new commander_1.Command();
 program
     .name("vira")
     .description("ViraJS CLI - Create projects and generate code")
-    .version("0.4.0-alpha");
+    .version("1.0.1");
 const SUPPORTED_TEMPLATES = ["frontend", "fullstack", "kanban"];
+/**
+ * Инициализация проекта в текущей директории
+ */
+program
+    .command("init")
+    .description("Initialize a Vira project in the current directory")
+    .option("-t, --template <template>", "Template type (frontend|fullstack|kanban). If not specified, interactive selection will be shown.")
+    .action(async (options) => {
+    const projectPath = process.cwd();
+    const projectName = path.basename(projectPath);
+    // Проверяем, не пуста ли директория
+    const files = await fs.readdir(projectPath);
+    const ignoreFiles = ['.git', '.gitignore', 'node_modules', '.DS_Store'];
+    const visibleFiles = files.filter(f => !ignoreFiles.includes(f) && !f.startsWith('.'));
+    if (visibleFiles.length > 0) {
+        const { proceed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "proceed",
+                message: `Directory is not empty. Continue anyway?`,
+                default: false,
+            },
+        ]);
+        if (!proceed) {
+            console.log(chalk_1.default.yellow("Init cancelled."));
+            process.exit(0);
+        }
+    }
+    console.log(chalk_1.default.blue(`\nInitializing Vira project in: ${projectPath}\n`));
+    // Интерактивный выбор шаблона, если не указан
+    let template;
+    if (options.template) {
+        template = options.template;
+        if (!SUPPORTED_TEMPLATES.includes(template)) {
+            console.error(chalk_1.default.red(`Unknown template: ${template}. Use one of: ${SUPPORTED_TEMPLATES.join(", ")}`));
+            process.exit(1);
+        }
+    }
+    else {
+        const { selectedTemplate } = await inquirer_1.default.prompt([
+            {
+                type: "list",
+                name: "selectedTemplate",
+                message: "Select a template:",
+                choices: [
+                    {
+                        name: "Frontend (React + Vite + Vira UI)",
+                        value: "frontend",
+                        short: "frontend",
+                    },
+                    {
+                        name: "Fullstack (Frontend + Go Backend + Docker)",
+                        value: "fullstack",
+                        short: "fullstack",
+                    },
+                    {
+                        name: "Kanban (Reference app with VRP)",
+                        value: "kanban",
+                        short: "kanban",
+                    },
+                ],
+                default: "frontend",
+            },
+        ]);
+        template = selectedTemplate;
+    }
+    // Создаём структуру проекта
+    await createProjectStructure(projectPath, template);
+    console.log(chalk_1.default.green(`\n✓ Project initialized successfully!\n`));
+    printNextSteps(projectName, template, true);
+});
 /**
  * Создание проекта
  */
@@ -159,18 +230,27 @@ program
     .command("generate")
     .alias("g")
     .description("Generate code")
-    .argument("<type>", "Type: component, service, page, model, route")
+    .argument("<type>", "Type: component, service, page, model, route, test")
     .argument("<name>", "Name")
     .option("-d, --dir <directory>", "Output directory", "src")
+    .option("-i, --interactive", "Interactive mode (for components and services)", false)
+    .option("--vrp", "Use Vira Reactive Protocol (VRP)", false)
+    .option("--no-vrp", "Do not use VRP (explicit)", false)
     .action(async (type, name, options) => {
     console.log(chalk_1.default.blue(`Generating ${type}: ${name}`));
     switch (type) {
         case "component":
         case "comp":
-            await generateComponent(name, options.dir);
+            await generateComponent(name, options.dir, {
+                interactive: options.interactive ?? false,
+                useVRP: options.vrp ? true : options.noVrp ? false : undefined,
+            });
             break;
         case "service":
-            await generateService(name, options.dir);
+            await generateService(name, options.dir, {
+                interactive: options.interactive ?? false,
+                useVRP: options.vrp ? true : options.noVrp ? false : undefined,
+            });
             break;
         case "page":
             await generatePage(name, options.dir);
@@ -181,6 +261,9 @@ program
         case "route":
             await generateRoute(name, options.dir);
             break;
+        case "test":
+            await generateTest(name, options.dir);
+            break;
         default:
             console.error(chalk_1.default.red(`Unknown type: ${type}`));
             process.exit(1);
@@ -227,22 +310,105 @@ make
     await generateEventHandler(name, options.dir);
     console.log(chalk_1.default.green(`✓ event handler ${name} created in ${options.dir}`));
 });
+make
+    .command("crud")
+    .description("Create CRUD handlers for a resource")
+    .argument("<name>", "Resource name (e.g. user)")
+    .option("-d, --dir <directory>", "Target directory", path.join("backend", "internal", "handlers"))
+    .option("-m, --model <model>", "Model name (defaults to capitalized resource name)")
+    .action(async (name, options) => {
+    await generateCRUDHandler(name, options.dir, options.model);
+    console.log(chalk_1.default.green(`✓ CRUD handlers for ${name} created in ${options.dir}`));
+});
 const protoCommand = program
     .command("proto")
-    .description("VRP protocol utilities");
+    .description("VRP (Vira Reactive Protocol) utilities");
 protoCommand
     .command("validate")
-    .description("Validate VRP protocol schema")
-    .action(async () => {
-    console.log(chalk_1.default.green("✓ VRP v0.1 protocol schema validated"));
-    console.log(chalk_1.default.gray("  See VIRA_PROTOCOL.md for full specification"));
+    .description("Validate VRP protocol schema and types")
+    .option("--file <path>", "Path to types file", path.join("backend", "internal", "types", "types.go"))
+    .action(async (options) => {
+    const typesPath = path.resolve(process.cwd(), options.file || path.join("backend", "internal", "types", "types.go"));
+    try {
+        if (await fs.pathExists(typesPath)) {
+            const content = await fs.readFile(typesPath, "utf8");
+            const structs = parseGoStructs(content);
+            if (structs.length === 0) {
+                console.log(chalk_1.default.yellow("⚠ No Go structs found in types file"));
+            }
+            else {
+                console.log(chalk_1.default.green(`✓ VRP v0.1 protocol schema validated`));
+                console.log(chalk_1.default.gray(`  Found ${structs.length} type(s): ${structs.map(s => s.name).join(", ")}`));
+                console.log(chalk_1.default.gray("  See VIRA_PROTOCOL.md for full specification"));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`⚠ Types file not found: ${typesPath}`));
+            console.log(chalk_1.default.gray("  VRP protocol schema structure is valid"));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow("⚠ Could not validate types file"));
+        console.log(chalk_1.default.gray("  VRP protocol schema structure is valid"));
+    }
 });
 protoCommand
     .command("generate")
-    .description("Generate protocol documentation/schemas")
-    .action(async () => {
-    console.log(chalk_1.default.green("✓ VRP protocol docs: VIRA_PROTOCOL.md"));
-    console.log(chalk_1.default.gray("  Protocol version: v0.1"));
+    .description("Generate protocol documentation and channel helpers")
+    .option("--file <path>", "Path to types file", path.join("backend", "internal", "types", "types.go"))
+    .option("--output <path>", "Output directory", "docs")
+    .action(async (options) => {
+    const typesPath = path.resolve(process.cwd(), options.file || path.join("backend", "internal", "types", "types.go"));
+    const outputDir = path.resolve(process.cwd(), options.output || "docs");
+    try {
+        if (await fs.pathExists(typesPath)) {
+            const content = await fs.readFile(typesPath, "utf8");
+            const structs = parseGoStructs(content);
+            await fs.ensureDir(outputDir);
+            // Генерируем документацию по каналам
+            const channelDocs = generateChannelDocumentation(structs);
+            await fs.writeFile(path.join(outputDir, "VRP_CHANNELS.md"), channelDocs);
+            console.log(chalk_1.default.green(`✓ VRP protocol docs generated`));
+            console.log(chalk_1.default.gray(`  Channels: ${outputDir}/VRP_CHANNELS.md`));
+            console.log(chalk_1.default.gray(`  Protocol version: v0.1`));
+            console.log(chalk_1.default.gray(`  Types: ${structs.length}`));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`⚠ Types file not found: ${typesPath}`));
+            console.log(chalk_1.default.gray("  Generating basic protocol documentation"));
+            await fs.ensureDir(outputDir);
+            const basicDocs = `# Vira Reactive Protocol (VRP)
+
+Protocol version: v0.1
+
+## Overview
+
+VRP is a WebSocket-based protocol for real-time state synchronization.
+
+## Message Types
+
+- \`handshake\` - Initial connection
+- \`ack\` - Acknowledgment
+- \`sub\` - Subscribe to channel
+- \`unsub\` - Unsubscribe from channel
+- \`update\` - Full state update
+- \`event\` - Event notification
+- \`diff\` - Partial state update
+- \`ping\` / \`pong\` - Keep-alive
+- \`error\` - Error message
+
+See VIRA_PROTOCOL.md for full specification.
+`;
+            await fs.writeFile(path.join(outputDir, "VRP_CHANNELS.md"), basicDocs);
+            console.log(chalk_1.default.green(`✓ Basic VRP protocol docs: ${outputDir}/VRP_CHANNELS.md`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red("✗ Error generating documentation"));
+        if (error instanceof Error) {
+            console.error(chalk_1.default.red(`  ${error.message}`));
+        }
+    }
 });
 program
     .command("doc")
@@ -268,14 +434,27 @@ program
     .option("--backend <path>", "Path to Go types file", path.join("backend", "internal", "types", "types.go"))
     .option("--frontend <path>", "Output TS types path (frontend)", path.join("frontend", "src", "vira-types.ts"))
     .option("--ui <path>", "Output TS types path (ui)", path.join("ui", "src", "vira-types.ts"))
+    .option("-w, --watch", "Watch mode: automatically sync on file changes", false)
     .action(async (options) => {
     if (options.types) {
-        await syncTypes(options);
+        if (options.watch) {
+            console.log(chalk_1.default.yellow("Watch mode is not yet implemented. Running once..."));
+            await syncTypes(options);
+        }
+        else {
+            await syncTypes(options);
+        }
     }
     else {
         console.log(chalk_1.default.yellow("Nothing to sync. Use --types to sync TypeScript types."));
     }
 });
+program
+    .command("validate")
+    .description("Validate project structure and configuration")
+    .action(async () => {
+    await validateProject();
+});
 program.parse(process.argv);
 /**
  * Создание структуры проекта
@@ -313,6 +492,16 @@ async function createFullstackProject(projectPath) {
     await createBackendStub(backendPath);
     await createDeployScaffold(deployPath);
     await createWorkspaceReadme(projectPath);
+    // 🎯 6️⃣ Добавляем корневой package.json с start:dev скриптом
+    const rootPackageJson = {
+        name: path.basename(projectPath),
+        version: "0.1.0",
+        private: true,
+        scripts: {
+            "start:dev": "cd deploy && docker compose -f docker-compose.dev.yml up -d && cd ../frontend && npm install && npm run dev",
+        },
+    };
+    await fs.writeJSON(path.join(projectPath, "package.json"), rootPackageJson, { spaces: 2 });
 }
 /**
  * Create Kanban reference app (VRP-only, no direct useState/fetch)
@@ -361,7 +550,10 @@ async function createFrontendProject(projectPath) {
         dependencies: {
             "@vira-ui/core": "^1.0.0",
             "@vira-ui/ui": "^1.0.0",
+            "@vira-ui/react": "^1.0.0",
             "lucide-react": "^0.400.0",
+            "uuid": "^9.0.1",
+            // lodash не нужен - используем debounceServiceMethod из @vira-ui/core!
         },
         devDependencies: {
             "@vira-ui/babel-plugin": "^1.0.0",
@@ -369,6 +561,7 @@ async function createFrontendProject(projectPath) {
             "@types/node": "^20.10.0",
             "@types/react": "^18.2.0",
             "@types/react-dom": "^18.2.0",
+            "@types/uuid": "^9.0.7",
             "react": "^18.2.0",
             "react-dom": "^18.2.0",
             "typescript": "^5.3.0",
@@ -440,10 +633,15 @@ async function createDeployScaffold(deployPath) {
 async function createWorkspaceReadme(projectPath) {
     await fs.writeFile(path.join(projectPath, "README.md"), readme_1.readme);
 }
-function printNextSteps(projectName, template) {
+function printNextSteps(projectName, template, isInit = false) {
     console.log(chalk_1.default.yellow(`\nNext steps:`));
     if (template === "fullstack") {
-        console.log(`  cd ${projectName}/frontend`);
+        if (!isInit) {
+            console.log(`  cd ${projectName}/frontend`);
+        }
+        else {
+            console.log(`  cd frontend`);
+        }
         console.log(`  npm install`);
         console.log(`  npm run dev`);
         console.log(`\nUI package:`);
@@ -455,41 +653,435 @@ function printNextSteps(projectName, template) {
         console.log(`  go mod tidy`);
         console.log(`  go run ./cmd/api`);
         console.log(`\nDev stack (DB/Redis/Kafka):`);
-        console.log(`  cd ../deploy && docker compose -f docker-compose.dev.yml up`);
+        if (!isInit) {
+            console.log(`  cd ../${projectName}/deploy && docker compose -f docker-compose.dev.yml up`);
+        }
+        else {
+            console.log(`  cd ../deploy && docker compose -f docker-compose.dev.yml up`);
+        }
         return;
     }
-    console.log(`  cd ${projectName}`);
+    if (!isInit) {
+        console.log(`  cd ${projectName}`);
+    }
     console.log(`  npm install`);
     console.log(`  npm run dev`);
 }
+/**
+ * Сбор VRP конфигурации
+ */
+async function collectVRPConfig(name, useVRP, interactive) {
+    if (useVRP === false) {
+        return null;
+    }
+    if (!interactive && useVRP !== true) {
+        return null;
+    }
+    // Если явно указано --vrp, используем значения по умолчанию
+    if (useVRP === true && !interactive) {
+        return {
+            channel: name.toLowerCase(),
+            stateType: `${name}State`,
+        };
+    }
+    // Интерактивный режим: спрашиваем
+    if (interactive && useVRP === undefined) {
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "useVRP",
+                message: "Use Vira Reactive Protocol (VRP) for state management?",
+                default: false,
+            },
+        ]);
+        if (!answer.useVRP) {
+            return null;
+        }
+    }
+    // Спрашиваем детали VRP
+    const config = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "channel",
+            message: "VRP channel name (e.g., 'user', 'task:123', 'demo'):",
+            default: name.toLowerCase(),
+            validate: (input) => input.length > 0 || "Channel name is required",
+        },
+        {
+            type: "input",
+            name: "stateType",
+            message: "State type name (interface name):",
+            default: `${name}State`,
+        },
+    ]);
+    return {
+        channel: config.channel,
+        stateType: config.stateType,
+    };
+}
+/**
+ * Сбор props компонента
+ */
+async function collectProps(name, hasVRP, interactive) {
+    if (!interactive) {
+        return { props: [], hasProps: true };
+    }
+    const answer = await inquirer_1.default.prompt([
+        {
+            type: "confirm",
+            name: "hasProps",
+            message: "Does this component need props?",
+            default: !hasVRP,
+        },
+    ]);
+    if (!answer.hasProps) {
+        return { props: [], hasProps: false };
+    }
+    const props = [];
+    let addMore = true;
+    while (addMore) {
+        const prop = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Prop name:",
+                validate: (input) => input.length > 0 || "Prop name is required",
+            },
+            {
+                type: "list",
+                name: "type",
+                message: "Prop type:",
+                choices: [
+                    "string",
+                    "number",
+                    "boolean",
+                    "ReactNode",
+                    "() => void",
+                    "(e: Event) => void",
+                    "string[]",
+                    "Custom",
+                ],
+                default: "string",
+            },
+            {
+                type: "input",
+                name: "customType",
+                message: "Custom type:",
+                when: (answers) => answers.type === "Custom",
+            },
+            {
+                type: "confirm",
+                name: "required",
+                message: "Required prop?",
+                default: true,
+            },
+        ]);
+        const propType = prop.type === "Custom" ? prop.customType : prop.type;
+        props.push({
+            name: prop.name,
+            type: propType,
+            required: prop.required,
+        });
+        const { continueAdding } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "continueAdding",
+                message: "Add another prop?",
+                default: true,
+            },
+        ]);
+        addMore = continueAdding;
+    }
+    return { props, hasProps: true };
+}
+/**
+ * Построение импортов
+ */
+function buildImports(vrpConfig, useViraUI) {
+    let imports = `import { createElement } from '@vira-ui/core';
+import type { ViraComponentProps } from '@vira-ui/core';`;
+    if (vrpConfig) {
+        imports += `\nimport { useViraState } from '@vira-ui/react';`;
+    }
+    if (useViraUI) {
+        imports += `\nimport { Container, Stack } from '@vira-ui/ui';`;
+    }
+    return imports;
+}
+/**
+ * Построение интерфейса props
+ */
+function buildPropsInterface(name, props) {
+    if (props.length === 0) {
+        return `export interface ${name}Props extends ViraComponentProps {
+  // Add your props here
+}`;
+    }
+    return `export interface ${name}Props extends ViraComponentProps {
+${props.map((p) => `  ${p.name}${p.required ? "" : "?"}: ${p.type};`).join("\n")}
+}`;
+}
+/**
+ * Построение тела компонента
+ */
+function buildComponentBody(name, vrpConfig, props, hasProps, useViraUI) {
+    const propsUsage = props.map((p) => `    ${p.name}={props.${p.name}}`).join("\n");
+    if (vrpConfig) {
+        return `  const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${vrpConfig.stateType}>('${vrpConfig.channel}', null);
+
+  // Use data from VRP state
+  // Example: const value = data?.field ?? defaultValue;
+
+  // 🎯 4️⃣ Для inline-редактирования с авто-save используйте встроенный watch() с debounce:
+  // import { watch, signal } from '@vira-ui/core';
+  // const [editValue, setEditValue] = signal('');
+  // watch(() => editValue(), (newValue) => {
+  //   sendDiff({ [field]: newValue, updated_at: new Date().toISOString() });
+  // }, { debounce: 500 });
+
+  return createElement('div', { className: '${name.toLowerCase()}' },
+${propsUsage ? propsUsage + ",\n" : ""}    // Add your content here
+  );`;
+    }
+    if (useViraUI) {
+        return `  return (
+    <Container>
+      <Stack>
+${propsUsage ? propsUsage.split('\n').map(p => `        ${p.replace('    ', '')}`).join('\n') + "\n" : ""}        {/* Add your content here */}
+      </Stack>
+    </Container>
+  );`;
+    }
+    return `  return createElement('div', { className: '${name.toLowerCase()}' },
+${propsUsage ? propsUsage + ",\n" : ""}    // Add your content here
+  );`;
+}
 /**
  * Генерация компонента
  */
-async function generateComponent(name, dir) {
+async function generateComponent(name, dir, config) {
     const componentPath = path.join(process.cwd(), dir, "components", `${name}.tsx`);
     await fs.ensureDir(path.dirname(componentPath));
-    const componentCode = `import { createElement } from '@vira-ui/core';
-import type { ViraComponentProps } from '@vira-ui/core';
-
-export interface ${name}Props extends ViraComponentProps {
-  // Add your props here
+    // Сбор конфигурации
+    const vrpConfig = await collectVRPConfig(name, config.useVRP, config.interactive);
+    const { props, hasProps } = await collectProps(name, !!vrpConfig, config.interactive);
+    // Спрашиваем про Vira UI, если интерактивный режим
+    let useViraUI = false;
+    if (config.interactive) {
+        const uiAnswer = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "useViraUI",
+                message: "Use Vira UI components (@vira-ui/ui)?",
+                default: true,
+            },
+        ]);
+        useViraUI = uiAnswer.useViraUI;
+    }
+    // Построение кода
+    const imports = buildImports(vrpConfig, useViraUI);
+    const propsInterface = buildPropsInterface(name, props);
+    const componentBody = buildComponentBody(name, vrpConfig, props, hasProps, useViraUI);
+    // Сборка финального кода
+    let componentCode = `${imports}
+`;
+    // Интерфейс состояния VRP
+    if (vrpConfig) {
+        componentCode += `export interface ${vrpConfig.stateType} {
+  // Add your state fields here
+  id?: string;
 }
 
-export function ${name}(props: ${name}Props) {
-  return createElement('div', { className: '${name.toLowerCase()}' },
-    // Add your content here
-  );
+`;
+    }
+    // Интерфейс props
+    if (hasProps || !vrpConfig) {
+        componentCode += `${propsInterface}
+
+`;
+    }
+    // Сигнатура функции
+    const functionSignature = hasProps || !vrpConfig
+        ? `export function ${name}(props: ${name}Props) {`
+        : `export function ${name}() {`;
+    componentCode += `${functionSignature}
+${componentBody}
 }
 `;
     await fs.writeFile(componentPath, componentCode);
 }
 /**
- * Генерация сервиса
+ * Сбор VRP конфигурации для сервиса
  */
-async function generateService(name, dir) {
-    const servicePath = path.join(process.cwd(), dir, "services", `${name}Service.ts`);
-    await fs.ensureDir(path.dirname(servicePath));
-    const serviceCode = `import { createViraService, signal } from '@vira-ui/core';
+async function collectServiceVRPConfig(name, useVRP, interactive) {
+    if (useVRP === false) {
+        return null;
+    }
+    if (!interactive && useVRP !== true) {
+        return null;
+    }
+    // Если явно указано --vrp, используем значения по умолчанию
+    if (useVRP === true && !interactive) {
+        return {
+            channel: name.toLowerCase(),
+            stateType: `${name}State`,
+        };
+    }
+    // Интерактивный режим: спрашиваем
+    if (interactive && useVRP === undefined) {
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "useVRP",
+                message: "Use Vira Reactive Protocol (VRP) for this service?",
+                default: true,
+            },
+        ]);
+        if (!answer.useVRP) {
+            return null;
+        }
+    }
+    // Спрашиваем детали VRP
+    const config = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "channel",
+            message: "VRP channel name:",
+            default: name.toLowerCase(),
+        },
+        {
+            type: "input",
+            name: "stateType",
+            message: "State type name:",
+            default: `${name}State`,
+        },
+    ]);
+    return {
+        channel: config.channel,
+        stateType: config.stateType,
+    };
+}
+/**
+ * Построение VRP-based сервиса
+ */
+function buildVRPService(name, vrpConfig) {
+    const lowerName = name.toLowerCase();
+    return `// ${name} service using Vira Core DI container + VRP
+import { createService, useService } from '@vira-ui/core';
+import { useViraState } from '@vira-ui/react';
+import { v4 as uuid } from 'uuid';
+
+export interface ${vrpConfig.stateType} {
+  // Add your state fields here
+  id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+// 🎯 3️⃣ Универсальный VRP hook для списков (переиспользуемый для любых сущностей)
+export function useVrpList<T>(channel: string) {
+  const { data, sendEvent, sendDiff } = useViraState<T[] | T>(channel, []);
+  const list = Array.isArray(data) ? data : Object.values(data || {});
+  return { data: list, sendEvent, sendDiff };
+}
+
+// Create ${lowerName} service (singleton via DI container)
+// Service holds pure business logic helpers
+createService('${lowerName}', () => ({
+  // Add your business logic methods here
+  processData(data: ${vrpConfig.stateType} | null): any {
+    if (!data) return null;
+    // Add processing logic
+    return data;
+  },
+}));
+
+// Hook for ${name} operations (combines service + VRP state)
+export function use${name}(id?: string) {
+  const channel = id ? \`${vrpConfig.channel}:\${id}\` : '${vrpConfig.channel}';
+  const { data, sendEvent, sendUpdate, sendDiff } = id 
+    ? useViraState<${vrpConfig.stateType}>(channel, null)
+    : useVrpList<${vrpConfig.stateType}>(channel);
+  const ${lowerName}Service = useService<{ processData: (data: ${vrpConfig.stateType} | null) => any }>('${lowerName}');
+
+  return {
+    data,
+    // 🎯 1️⃣ Создание с авто-генерацией UUID на фронте (VRP сразу знает id, не надо ждать бэка)
+    create(item: Omit<${vrpConfig.stateType}, 'id' | 'created_at' | 'updated_at'>) {
+      const id = uuid();
+      const newItem: ${vrpConfig.stateType} = {
+        ...item,
+        id,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+      sendEvent('${lowerName}.created', {
+        ...newItem,
+        timestamp: new Date().toISOString()
+      });
+    },
+    // Update operations
+    update(updates: Partial<${vrpConfig.stateType}>) {
+      sendDiff(updates);
+      sendEvent('${lowerName}.updated', { 
+        ...updates,
+        updated_at: new Date().toISOString(),
+        timestamp: new Date().toISOString()
+      });
+    },
+    // Delete operation
+    delete(itemId: string) {
+      sendEvent('${lowerName}.deleted', { 
+        id: itemId,
+        timestamp: new Date().toISOString()
+      });
+    },
+    sendEvent,
+    sendDiff,
+    // Service methods
+    processData() {
+      return ${lowerName}Service.processData(data);
+    },
+  };
+}
+
+// 🎯 2️⃣ Сервис для bulk actions с VRP (переиспользуемый для любых сущностей)
+// Используем batch() из @vira-ui/core для оптимизации множественных обновлений
+import { batch } from '@vira-ui/core';
+
+createService('${lowerName}Bulk', () => ({
+  bulkUpdate(ids: string[], payload: Partial<${vrpConfig.stateType}>, sendEvent: Function) {
+    // batch() группирует все обновления в один цикл - компоненты обновятся только один раз!
+    batch(() => {
+      ids.forEach(id => {
+        sendEvent('${lowerName}.updated', { 
+          id, 
+          ...payload, 
+          updated_at: new Date().toISOString(),
+          timestamp: new Date().toISOString() 
+        });
+      });
+    });
+  },
+  bulkDelete(ids: string[], sendEvent: Function) {
+    // batch() для оптимизации массового удаления
+    batch(() => {
+      ids.forEach(id => {
+        sendEvent('${lowerName}.deleted', { 
+          id, 
+          timestamp: new Date().toISOString() 
+        });
+      });
+    });
+  },
+}));
+`;
+}
+/**
+ * Построение стандартного сервиса с signals
+ */
+function buildStandardService(name) {
+    return `import { createViraService, signal } from '@vira-ui/core';
 
 export const ${name}Service = createViraService('${name.toLowerCase()}', () => {
   const data = signal([]);
@@ -517,6 +1109,19 @@ export const ${name}Service = createViraService('${name.toLowerCase()}', () => {
   };
 });
 `;
+}
+/**
+ * Генерация сервиса
+ */
+async function generateService(name, dir, config) {
+    const servicePath = path.join(process.cwd(), dir, "services", `${name}Service.ts`);
+    await fs.ensureDir(path.dirname(servicePath));
+    // Сбор VRP конфигурации
+    const vrpConfig = await collectServiceVRPConfig(name, config.useVRP, config.interactive);
+    // Построение кода
+    const serviceCode = vrpConfig
+        ? buildVRPService(name, vrpConfig)
+        : buildStandardService(name);
     await fs.writeFile(servicePath, serviceCode);
 }
 /**
@@ -525,9 +1130,49 @@ export const ${name}Service = createViraService('${name.toLowerCase()}', () => {
 async function generatePage(name, dir) {
     const pagePath = path.join(process.cwd(), dir, "pages", `${name}Page.tsx`);
     await fs.ensureDir(path.dirname(pagePath));
-    const pageCode = `import { createElement } from '@vira-ui/core';
+    const pageCode = `import { createService, useService, createElement } from '@vira-ui/core';
+import { useViraState } from '@vira-ui/react';
+
+// 🎯 5️⃣ VRP notifications: очередь с максимумом (предотвращает перегрузку фронта)
+const MAX_NOTIFICATIONS = 5;
+
+// Создаём сервис для управления состоянием страницы
+createService('${name.toLowerCase()}Page', () => ({
+  searchQuery: '',
+  selectedIds: new Set<string>(),
+  
+  setSearchQuery(value: string) {
+    this.searchQuery = value;
+  },
+  
+  toggleSelect(id: string) {
+    if (this.selectedIds.has(id)) {
+      this.selectedIds.delete(id);
+    } else {
+      this.selectedIds.add(id);
+    }
+  },
+  
+  clearSelection() {
+    this.selectedIds.clear();
+  },
+}));
 
 export function ${name}Page() {
+  // VRP для списка
+  // const { data, create, sendEvent } = use${name}();
+  
+  // VRP для real-time уведомлений с лимитом
+  const notificationsState = useViraState<any[]>('notifications:${name.toLowerCase()}', []);
+  
+  // Используем сервис страницы
+  const pageService = useService('${name.toLowerCase()}Page');
+  
+  // Обработка уведомлений с лимитом очереди
+  if (notificationsState.data && notificationsState.data.length > MAX_NOTIFICATIONS) {
+    notificationsState.data = notificationsState.data.slice(-MAX_NOTIFICATIONS);
+  }
+
   return createElement('div', { className: '${name.toLowerCase()}-page' },
     createElement('h1', null, '${name}'),
     // Add your content here
@@ -570,6 +1215,78 @@ export const ${name}Route = reactiveRoute({
 `;
     await fs.writeFile(routePath, routeCode);
 }
+/**
+ * Генерация теста
+ */
+async function generateTest(name, dir) {
+    // Определяем тип файла (component, service, page)
+    const componentPath = path.join(process.cwd(), dir, "components", `${name}.tsx`);
+    const servicePath = path.join(process.cwd(), dir, "services", `${name}Service.ts`);
+    const pagePath = path.join(process.cwd(), dir, "pages", `${name}Page.tsx`);
+    let testPath;
+    let testCode;
+    if (await fs.pathExists(componentPath)) {
+        // Тест для компонента
+        testPath = path.join(process.cwd(), dir, "components", `${name}.test.tsx`);
+        testCode = `import React from 'react';
+import { render } from '@testing-library/react';
+import { ${name} } from './${name}';
+import type { ${name}Props } from './${name}';
+
+describe('${name}', () => {
+  it('renders correctly', () => {
+    const props: ${name}Props = {
+      // Add test props here
+    };
+    const { container } = render(React.createElement(${name}, props));
+    expect(container).toBeTruthy();
+  });
+});
+`;
+    }
+    else if (await fs.pathExists(servicePath)) {
+        // Тест для сервиса
+        testPath = path.join(process.cwd(), dir, "services", `${name}Service.test.ts`);
+        testCode = `import { ${name}Service } from './${name}Service';
+
+describe('${name}Service', () => {
+  it('should be defined', () => {
+    expect(${name}Service).toBeDefined();
+  });
+
+  // Add more tests here
+});
+`;
+    }
+    else if (await fs.pathExists(pagePath)) {
+        // Тест для страницы
+        testPath = path.join(process.cwd(), dir, "pages", `${name}Page.test.tsx`);
+        testCode = `import React from 'react';
+import { render } from '@testing-library/react';
+import { ${name}Page } from './${name}Page';
+
+describe('${name}Page', () => {
+  it('renders correctly', () => {
+    const { container } = render(React.createElement(${name}Page));
+    expect(container).toBeTruthy();
+  });
+});
+`;
+    }
+    else {
+        // Общий тест, если файл не найден
+        testPath = path.join(process.cwd(), dir, "__tests__", `${name}.test.ts`);
+        await fs.ensureDir(path.dirname(testPath));
+        testCode = `describe('${name}', () => {
+  it('should work', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+    }
+    await fs.ensureDir(path.dirname(testPath));
+    await fs.writeFile(testPath, testCode);
+}
 /**
  * Sync TypeScript types from Go structs (scaffold-level parser)
  */
@@ -728,6 +1445,50 @@ function toCamel(name) {
         return name;
     return name.charAt(0).toLowerCase() + name.slice(1);
 }
+/**
+ * Генерация документации по VRP каналам
+ */
+function generateChannelDocumentation(structs) {
+    const lines = [];
+    lines.push("# Vira Reactive Protocol (VRP) Channels");
+    lines.push("");
+    lines.push("Protocol version: v0.1");
+    lines.push("");
+    lines.push("## Available Channels");
+    lines.push("");
+    lines.push("The following channels are available based on your Go types:");
+    lines.push("");
+    for (const struct of structs) {
+        const channelName = struct.name.toLowerCase();
+        lines.push(`### \`${channelName}\` / \`${channelName}:{id}\``);
+        lines.push("");
+        lines.push(`Type: \`${struct.name}\``);
+        lines.push("");
+        if (struct.fields.length > 0) {
+            lines.push("Fields:");
+            lines.push("");
+            for (const field of struct.fields) {
+                const jsonName = field.json || toCamel(field.name);
+                const tsType = goTypeToTs(field.type);
+                lines.push(`- \`${jsonName}\`: \`${tsType}\``);
+            }
+            lines.push("");
+        }
+    }
+    lines.push("## Usage");
+    lines.push("");
+    lines.push("```typescript");
+    lines.push("import { useViraState } from '@vira-ui/react';");
+    lines.push("");
+    if (structs.length > 0) {
+        const firstStruct = structs[0];
+        lines.push(`const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${firstStruct.name}>('${firstStruct.name.toLowerCase()}', null);`);
+    }
+    lines.push("```");
+    lines.push("");
+    lines.push("See VIRA_PROTOCOL.md for full specification.");
+    return lines.join("\n");
+}
 /**
  * Go HTTP handler scaffold
  */
@@ -829,3 +1590,429 @@ function toPascal(value) {
         .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
         .join("");
 }
+/**
+ * Генерация CRUD handlers для ресурса
+ */
+async function generateCRUDHandler(name, dir, modelName) {
+    const safeName = name.toLowerCase();
+    const handlerName = capitalize(name);
+    const model = modelName || capitalize(name);
+    const targetDir = path.join(process.cwd(), dir);
+    await fs.ensureDir(targetDir);
+    const handlerCode = `package handlers
+
+import (
+  "encoding/json"
+  "net/http"
+  "strconv"
+  "time"
+  "github.com/gorilla/mux"
+  "github.com/go-playground/validator/v10"
+  "github.com/google/uuid"
+)
+
+var validate = validator.New()
+
+// 🎯 Production-ready: Pagination support
+type PaginationParams struct {
+  Limit  int \`json:"limit"\`
+  Offset int \`json:"offset"\`
+  Cursor string \`json:"cursor,omitempty"\`
+}
+
+// 🎯 Production-ready: List response with pagination
+type ${handlerName}ListResponse struct {
+  Items  []${model} \`json:"items"\`
+  Total  int        \`json:"total"\`
+  Limit  int        \`json:"limit"\`
+  Offset int        \`json:"offset"\`
+  HasMore bool      \`json:"has_more"\`
+}
+
+// 🎯 Production-ready: Event logging structure
+type ${handlerName}Event struct {
+  ID        string    \`json:"id"\`
+  Type      string    \`json:"type"\` // created, updated, deleted
+  EntityID  string    \`json:"entity_id"\`
+  UserID    string    \`json:"user_id,omitempty"\`
+  OldValue  *${model} \`json:"old_value,omitempty"\`
+  NewValue  *${model} \`json:"new_value,omitempty"\`
+  Timestamp time.Time \`json:"timestamp"\`
+}
+
+// 🎯 Production-ready: Batch request/response
+type BatchUpdateRequest struct {
+  IDs     []string           \`json:"ids" validate:"required,min=1"\`
+  Payload map[string]interface{} \`json:"payload" validate:"required"\`
+}
+
+type BatchDeleteRequest struct {
+  IDs []string \`json:"ids" validate:"required,min=1"\`
+}
+
+// List${handlerName} handles GET /${safeName} with pagination
+func List${handlerName}(w http.ResponseWriter, r *http.Request) {
+  w.Header().Set("Content-Type", "application/json")
+  
+  // 🎯 Production-ready: Parse pagination params (limit, offset, cursor)
+  limit := 50 // default
+  offset := 0
+  
+  if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
+    if parsed, err := strconv.Atoi(limitStr); err == nil && parsed > 0 && parsed <= 100 {
+      limit = parsed
+    }
+  }
+  
+  if offsetStr := r.URL.Query().Get("offset"); offsetStr != "" {
+    if parsed, err := strconv.Atoi(offsetStr); err == nil && parsed >= 0 {
+      offset = parsed
+    }
+  }
+  
+  // TODO: Implement actual DB query with limit/offset
+  // items, total, err := db.List${handlerName}(limit, offset)
+  // if err != nil {
+  //   http.Error(w, err.Error(), http.StatusInternalServerError)
+  //   return
+  // }
+  
+  // 🎯 Production-ready: Redis caching (commented for now - implement with your cache layer)
+  // cacheKey := fmt.Sprintf("${safeName}:list:limit=%d:offset=%d", limit, offset)
+  // if cached := redis.Get(cacheKey); cached != nil {
+  //   json.NewEncoder(w).Encode(cached)
+  //   return
+  // }
+  
+  response := ${handlerName}ListResponse{
+    Items:   []${model}{},
+    Total:   0,
+    Limit:   limit,
+    Offset:  offset,
+    HasMore: false,
+  }
+  
+  // 🎯 Production-ready: Cache response (TTL 30s for lists)
+  // redis.Set(cacheKey, response, 30*time.Second)
+  
+  json.NewEncoder(w).Encode(response)
+}
+
+// Get${handlerName} handles GET /${safeName}/{id}
+func Get${handlerName}(w http.ResponseWriter, r *http.Request) {
+  vars := mux.Vars(r)
+  id := vars["id"]
+  
+  w.Header().Set("Content-Type", "application/json")
+  
+  // 🎯 Production-ready: Redis caching for detail views
+  // cacheKey := fmt.Sprintf("${safeName}:detail:%s", id)
+  // if cached := redis.Get(cacheKey); cached != nil {
+  //   json.NewEncoder(w).Encode(cached)
+  //   return
+  // }
+  
+  // TODO: Implement actual DB query
+  // item, err := db.Get${handlerName}(id)
+  // if err != nil {
+  //   http.Error(w, err.Error(), http.StatusNotFound)
+  //   return
+  // }
+  
+  item := ${model}{ID: id}
+  
+  // 🎯 Production-ready: Cache detail (TTL 5min)
+  // redis.Set(cacheKey, item, 5*time.Minute)
+  
+  json.NewEncoder(w).Encode(item)
+}
+
+// Create${handlerName} handles POST /${safeName}
+func Create${handlerName}(w http.ResponseWriter, r *http.Request) {
+  var input ${model}
+  
+  if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+    http.Error(w, "Invalid JSON", http.StatusBadRequest)
+    return
+  }
+  
+  // 🎯 Production-ready: Validation (email, phone, unique fields)
+  if err := validate.Struct(input); err != nil {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(http.StatusBadRequest)
+    json.NewEncoder(w).Encode(map[string]string{
+      "error": "Validation failed",
+      "details": err.Error(),
+    })
+    return
+  }
+  
+  // Generate UUID if not provided
+  if input.ID == "" {
+    input.ID = uuid.New().String()
+  }
+  
+  input.CreatedAt = time.Now()
+  input.UpdatedAt = time.Now()
+  
+  // TODO: Implement actual DB insert
+  // if err := db.Create${handlerName}(&input); err != nil {
+  //   http.Error(w, err.Error(), http.StatusInternalServerError)
+  //   return
+  // }
+  
+  // 🎯 Production-ready: Log event for audit trail
+  event := ${handlerName}Event{
+    ID:        uuid.New().String(),
+    Type:      "created",
+    EntityID:  input.ID,
+    NewValue:  &input,
+    Timestamp: time.Now(),
+  }
+  // logEvent(event) // Implement event logging to client_events table
+  
+  // 🎯 Production-ready: Invalidate cache
+  // redis.Del("${safeName}:list:*")
+  
+  // 🎯 Production-ready: Emit VRP event (batchEmit for large lists)
+  // vrp.BatchEmit("${safeName}", "created", input)
+  
+  w.Header().Set("Content-Type", "application/json")
+  w.WriteHeader(http.StatusCreated)
+  json.NewEncoder(w).Encode(input)
+}
+
+// Update${handlerName} handles PUT /${safeName}/{id}
+func Update${handlerName}(w http.ResponseWriter, r *http.Request) {
+  vars := mux.Vars(r)
+  id := vars["id"]
+  
+  var input ${model}
+  if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+    http.Error(w, "Invalid JSON", http.StatusBadRequest)
+    return
+  }
+  
+  // 🎯 Production-ready: Get old value for event logging
+  // oldValue, _ := db.Get${handlerName}(id)
+  
+  // 🎯 Production-ready: Validation
+  if err := validate.Struct(input); err != nil {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(http.StatusBadRequest)
+    json.NewEncoder(w).Encode(map[string]string{
+      "error": "Validation failed",
+      "details": err.Error(),
+    })
+    return
+  }
+  
+  input.ID = id
+  input.UpdatedAt = time.Now()
+  
+  // TODO: Implement actual DB update
+  // if err := db.Update${handlerName}(&input); err != nil {
+  //   http.Error(w, err.Error(), http.StatusNotFound)
+  //   return
+  // }
+  
+  // 🎯 Production-ready: Log event with old/new values
+  // event := ${handlerName}Event{
+  //   ID:        uuid.New().String(),
+  //   Type:      "updated",
+  //   EntityID:  id,
+  //   OldValue:  oldValue,
+  //   NewValue:  &input,
+  //   Timestamp: time.Now(),
+  // }
+  // logEvent(event)
+  
+  // 🎯 Production-ready: Invalidate cache
+  // redis.Del(fmt.Sprintf("${safeName}:detail:%s", id), "${safeName}:list:*")
+  
+  // 🎯 Production-ready: Emit VRP diff for real-time updates
+  // vrp.SendDiff("${safeName}:" + id, input)
+  
+  w.Header().Set("Content-Type", "application/json")
+  json.NewEncoder(w).Encode(input)
+}
+
+// Delete${handlerName} handles DELETE /${safeName}/{id}
+func Delete${handlerName}(w http.ResponseWriter, r *http.Request) {
+  vars := mux.Vars(r)
+  id := vars["id"]
+  
+  // 🎯 Production-ready: Get value for event logging
+  // oldValue, _ := db.Get${handlerName}(id)
+  
+  // TODO: Implement actual DB delete
+  // if err := db.Delete${handlerName}(id); err != nil {
+  //   http.Error(w, err.Error(), http.StatusNotFound)
+  //   return
+  // }
+  
+  // 🎯 Production-ready: Log deletion event
+  // event := ${handlerName}Event{
+  //   ID:        uuid.New().String(),
+  //   Type:      "deleted",
+  //   EntityID:  id,
+  //   OldValue:  oldValue,
+  //   Timestamp: time.Now(),
+  // }
+  // logEvent(event)
+  
+  // 🎯 Production-ready: Invalidate cache
+  // redis.Del(fmt.Sprintf("${safeName}:detail:%s", id), "${safeName}:list:*")
+  
+  // 🎯 Production-ready: Emit VRP event
+  // vrp.SendEvent("${safeName}", "deleted", map[string]string{"id": id})
+  
+  w.WriteHeader(http.StatusNoContent)
+}
+
+// 🎯 Production-ready: BatchUpdate handles POST /${safeName}/batch/update
+func BatchUpdate${handlerName}(w http.ResponseWriter, r *http.Request) {
+  var req BatchUpdateRequest
+  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+    http.Error(w, "Invalid JSON", http.StatusBadRequest)
+    return
+  }
+  
+  if err := validate.Struct(req); err != nil {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(http.StatusBadRequest)
+    json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+    return
+  }
+  
+  // TODO: Implement batch update in transaction
+  // tx := db.Begin()
+  // for _, id := range req.IDs {
+  //   if err := tx.Update${handlerName}(id, req.Payload); err != nil {
+  //     tx.Rollback()
+  //     http.Error(w, err.Error(), http.StatusInternalServerError)
+  //     return
+  //   }
+  // }
+  // tx.Commit()
+  
+  // 🎯 Production-ready: Batch emit VRP events
+  // vrp.BatchEmit("${safeName}", "updated", req)
+  
+  // Invalidate cache
+  // redis.Del("${safeName}:*")
+  
+  w.Header().Set("Content-Type", "application/json")
+  json.NewEncoder(w).Encode(map[string]interface{}{
+    "updated": len(req.IDs),
+    "ids": req.IDs,
+  })
+}
+
+// 🎯 Production-ready: BatchDelete handles POST /${safeName}/batch/delete
+func BatchDelete${handlerName}(w http.ResponseWriter, r *http.Request) {
+  var req BatchDeleteRequest
+  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+    http.Error(w, "Invalid JSON", http.StatusBadRequest)
+    return
+  }
+  
+  if err := validate.Struct(req); err != nil {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(http.StatusBadRequest)
+    json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+    return
+  }
+  
+  // TODO: Implement batch delete in transaction
+  // tx := db.Begin()
+  // for _, id := range req.IDs {
+  //   if err := tx.Delete${handlerName}(id); err != nil {
+  //     tx.Rollback()
+  //     http.Error(w, err.Error(), http.StatusInternalServerError)
+  //     return
+  //   }
+  // }
+  // tx.Commit()
+  
+  // 🎯 Production-ready: Batch emit VRP events
+  // vrp.BatchEmit("${safeName}", "deleted", req)
+  
+  // Invalidate cache
+  // redis.Del("${safeName}:*")
+  
+  w.WriteHeader(http.StatusNoContent)
+}
+`;
+    await fs.writeFile(path.join(targetDir, `${safeName}_crud.go`), handlerCode);
+}
+/**
+ * Валидация проекта
+ */
+async function validateProject() {
+    const cwd = process.cwd();
+    const errors = [];
+    const warnings = [];
+    console.log(chalk_1.default.blue("\nValidating Vira project...\n"));
+    // Проверка структуры frontend проекта
+    const frontendPath = path.join(cwd, "frontend");
+    const frontendExists = await fs.pathExists(frontendPath);
+    if (frontendExists) {
+        const requiredFiles = [
+            "package.json",
+            "vite.config.ts",
+            "tsconfig.json",
+            "src/main.tsx",
+        ];
+        for (const file of requiredFiles) {
+            const filePath = path.join(frontendPath, file);
+            if (!(await fs.pathExists(filePath))) {
+                errors.push(`Missing frontend file: ${file}`);
+            }
+        }
+        // Проверка структуры директорий
+        const requiredDirs = ["src/components", "src/services", "src/pages"];
+        for (const dir of requiredDirs) {
+            const dirPath = path.join(frontendPath, dir);
+            if (!(await fs.pathExists(dirPath))) {
+                warnings.push(`Missing frontend directory: ${dir}`);
+            }
+        }
+    }
+    else {
+        // Проверка standalone frontend
+        if (!(await fs.pathExists(path.join(cwd, "package.json")))) {
+            errors.push("Missing package.json");
+        }
+    }
+    // Проверка структуры backend проекта
+    const backendPath = path.join(cwd, "backend");
+    if (await fs.pathExists(backendPath)) {
+        const requiredFiles = ["go.mod", "cmd/api/main.go"];
+        for (const file of requiredFiles) {
+            const filePath = path.join(backendPath, file);
+            if (!(await fs.pathExists(filePath))) {
+                errors.push(`Missing backend file: ${file}`);
+            }
+        }
+    }
+    // Вывод результатов
+    if (errors.length > 0) {
+        console.log(chalk_1.default.red("✗ Errors found:"));
+        errors.forEach((err) => console.log(chalk_1.default.red(`  - ${err}`)));
+    }
+    if (warnings.length > 0) {
+        console.log(chalk_1.default.yellow("\n⚠ Warnings:"));
+        warnings.forEach((warn) => console.log(chalk_1.default.yellow(`  - ${warn}`)));
+    }
+    if (errors.length === 0 && warnings.length === 0) {
+        console.log(chalk_1.default.green("✓ Project structure is valid!"));
+    }
+    else if (errors.length === 0) {
+        console.log(chalk_1.default.green("\n✓ Project structure is valid (with warnings)"));
+    }
+    else {
+        console.log(chalk_1.default.red("\n✗ Project validation failed"));
+        process.exit(1);
+    }
+}