@vira-ui/cli 0.3.3-alpha → 0.4.0-alpha

package/dist/index.js

@@ -49,11 +49,51 @@ const commander_1 = require("commander");
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const backendReadme_1 = require("./go/backendReadme");
+const backendEnvExample_1 = require("./go/backendEnvExample");
+const dockerfile_1 = require("./go/dockerfile");
+const kafkaYaml_1 = require("./go/kafkaYaml");
+const redisYaml_1 = require("./go/redisYaml");
+const dbYaml_1 = require("./go/dbYaml");
+const appYaml_1 = require("./go/appYaml");
+const typesGo_1 = require("./go/typesGo");
+const kafkaGo_1 = require("./go/kafkaGo");
+const redisGo_1 = require("./go/redisGo");
+const sqlcYaml_1 = require("./go/sqlcYaml");
+const dbGo_1 = require("./go/dbGo");
+const configGo_1 = require("./go/configGo");
+const mainGo_1 = require("./go/mainGo");
+const goMod_1 = require("./go/goMod");
+const useViraState_1 = require("./go/useViraState");
+const useViraStream_1 = require("./go/useViraStream");
+const channelHelpers_1 = require("./go/channelHelpers");
+const eventsAPI_1 = require("./go/eventsAPI");
+const eventHandlerTemplate_1 = require("./go/eventHandlerTemplate");
+const registryGo_1 = require("./go/registryGo");
+const stateStore_1 = require("./go/stateStore");
+const appTsx_1 = require("./react/appTsx");
+const kanbanAppTsx_1 = require("./react/kanbanAppTsx");
+const kanbanModels_1 = require("./react/kanbanModels");
+const kanbanService_1 = require("./react/kanbanService");
+const kanbanBoard_1 = require("./react/kanbanBoard");
+const kanbanColumn_1 = require("./react/kanbanColumn");
+const kanbanCard_1 = require("./react/kanbanCard");
+const mainTsx_1 = require("./react/mainTsx");
+const indexCss_1 = require("./react/indexCss");
+const indexHtml_1 = require("./react/indexHtml");
+const envExample_1 = require("./react/envExample");
+const envLocal_1 = require("./react/envLocal");
+const viteConfig_1 = require("./react/viteConfig");
+const tsconfig_1 = require("./react/tsconfig");
+const dockerCompose_1 = require("./go/dockerCompose");
+const dockerComposeProd_1 = require("./go/dockerComposeProd");
+const readme_1 = require("./go/readme");
 const program = new commander_1.Command();
 program
     .name("vira")
     .description("ViraJS CLI - Create projects and generate code")
-    .version("0.3.0-alpha");
+    .version("0.4.0-alpha");
+const SUPPORTED_TEMPLATES = ["frontend", "fullstack", "kanban"];
 /**
  * Создание проекта
  */
@@ -61,22 +101,24 @@ program
     .command("create")
     .description("Create a new Vira project")
     .argument("<name>", "Project name")
-    .option("-t, --template <template>", "Template type", "default")
+    .option("-t, --template <template>", "Template type (frontend|fullstack|kanban)", "frontend")
     .action(async (name, options) => {
     console.log(chalk_1.default.blue(`Creating Vira project: ${name}`));
     const projectPath = path.resolve(process.cwd(), name);
+    const template = (options.template || "frontend");
+    if (!SUPPORTED_TEMPLATES.includes(template)) {
+        console.error(chalk_1.default.red(`Unknown template: ${template}. Use one of: ${SUPPORTED_TEMPLATES.join(", ")}`));
+        process.exit(1);
+    }
     // Проверяем, существует ли директория
     if (await fs.pathExists(projectPath)) {
         console.error(chalk_1.default.red(`Directory ${name} already exists!`));
         process.exit(1);
     }
     // Создаём структуру проекта
-    await createProjectStructure(projectPath, options.template);
+    await createProjectStructure(projectPath, template);
     console.log(chalk_1.default.green(`✓ Project ${name} created successfully!`));
-    console.log(chalk_1.default.yellow(`\nNext steps:`));
-    console.log(`  cd ${name}`);
-    console.log(`  npm install`);
-    console.log(`  npm run dev`);
+    printNextSteps(name, template);
 });
 /**
  * Генерация компонента
@@ -113,17 +155,169 @@ program
     }
     console.log(chalk_1.default.green(`✓ ${type} ${name} generated successfully!`));
 });
+/**
+ * Генерация Go-заготовок (backend)
+ */
+const make = program.command("make").description("Backend scaffolding (Go)");
+make
+    .command("handler")
+    .description("Create Go HTTP handler")
+    .argument("<name>", "Handler name (e.g. user)")
+    .option("-d, --dir <directory>", "Target directory", path.join("backend", "internal", "handlers"))
+    .action(async (name, options) => {
+    await generateGoHandler(name, options.dir);
+    console.log(chalk_1.default.green(`✓ handler ${name} created in ${options.dir}`));
+});
+make
+    .command("model")
+    .description("Create Go model struct")
+    .argument("<name>", "Model name (e.g. User)")
+    .option("-d, --dir <directory>", "Target directory", path.join("backend", "internal", "models"))
+    .action(async (name, options) => {
+    await generateGoModel(name, options.dir);
+    console.log(chalk_1.default.green(`✓ model ${name} created in ${options.dir}`));
+});
+make
+    .command("migration")
+    .description("Create SQL migration (up/down)")
+    .argument("<name>", "Migration name, kebab-case (e.g. create-users)")
+    .option("-d, --dir <directory>", "Target directory", "migrations")
+    .action(async (name, options) => {
+    await generateMigration(name, options.dir);
+    console.log(chalk_1.default.green(`✓ migration ${name} created in ${options.dir}`));
+});
+make
+    .command("event")
+    .description("Create Go event handler stub")
+    .argument("<name>", "Event name, e.g. task.update")
+    .option("-d, --dir <directory>", "Target directory", path.join("backend", "internal", "events"))
+    .action(async (name, options) => {
+    await generateEventHandler(name, options.dir);
+    console.log(chalk_1.default.green(`✓ event handler ${name} created in ${options.dir}`));
+});
+const protoCommand = program
+    .command("proto")
+    .description("VRP 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"));
+});
+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"));
+});
+program
+    .command("doc")
+    .description("Generate CLI docs into docs/cli.md")
+    .action(async () => {
+    const info = program.helpInformation();
+    const doc = `# Vira CLI Commands
+
+\`\`\`
+${info}
+\`\`\`
+`;
+    const docsDir = path.join(process.cwd(), "docs");
+    await fs.ensureDir(docsDir);
+    const target = path.join(docsDir, "cli.md");
+    await fs.writeFile(target, doc);
+    console.log(chalk_1.default.green(`✓ CLI docs generated at ${target}`));
+});
+program
+    .command("sync")
+    .description("Sync artifacts between backend and frontend")
+    .option("--types", "Sync TypeScript types from Go structs", true)
+    .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"))
+    .action(async (options) => {
+    if (options.types) {
+        await syncTypes(options);
+    }
+    else {
+        console.log(chalk_1.default.yellow("Nothing to sync. Use --types to sync TypeScript types."));
+    }
+});
 program.parse(process.argv);
 /**
  * Создание структуры проекта
  */
 async function createProjectStructure(projectPath, template) {
+    if (template === "fullstack") {
+        await createFullstackProject(projectPath);
+        return;
+    }
+    if (template === "kanban") {
+        await createKanbanProject(projectPath);
+        return;
+    }
+    // Default: frontend-only project
+    await createFrontendProject(projectPath);
+}
+/**
+ * Создание fullstack-структуры (frontend + backend + инфраструктура)
+ */
+async function createFullstackProject(projectPath) {
+    const frontendPath = path.join(projectPath, "frontend");
+    const backendPath = path.join(projectPath, "backend");
+    const uiPath = path.join(projectPath, "ui");
+    const cliPath = path.join(projectPath, "cli");
+    const pluginsPath = path.join(projectPath, "plugins");
+    const migrationsPath = path.join(projectPath, "migrations");
+    const deployPath = path.join(projectPath, "deploy");
+    await fs.ensureDir(projectPath);
+    await fs.ensureDir(uiPath);
+    await fs.ensureDir(cliPath);
+    await fs.ensureDir(pluginsPath);
+    await fs.ensureDir(migrationsPath);
+    await fs.ensureDir(deployPath);
+    await fs.writeFile(path.join(migrationsPath, ".gitkeep"), "");
+    await createFrontendProject(frontendPath);
+    await createFrontendProject(uiPath);
+    await createBackendStub(backendPath);
+    await createDeployScaffold(deployPath);
+    await createWorkspaceReadme(projectPath);
+}
+/**
+ * Create Kanban reference app (VRP-only, no direct useState/fetch)
+ */
+async function createKanbanProject(projectPath) {
+    await createFrontendProject(projectPath);
+    // Write Kanban-specific files
+    await fs.writeFile(path.join(projectPath, "src", "App.tsx"), kanbanAppTsx_1.kanbanAppTsx);
+    await fs.writeFile(path.join(projectPath, "src", "models", "kanban.ts"), kanbanModels_1.kanbanModels);
+    await fs.writeFile(path.join(projectPath, "src", "services", "kanban.ts"), kanbanService_1.kanbanService);
+    await fs.writeFile(path.join(projectPath, "src", "components", "KanbanBoard.tsx"), kanbanBoard_1.kanbanBoard);
+    await fs.writeFile(path.join(projectPath, "src", "components", "KanbanColumn.tsx"), kanbanColumn_1.kanbanColumn);
+    await fs.writeFile(path.join(projectPath, "src", "components", "KanbanCard.tsx"), kanbanCard_1.kanbanCard);
+    // Note: Backend handlers should be generated separately via:
+    // vira make event kanban.card.create
+    // vira make event kanban.card.move
+    // vira make event kanban.card.delete
+    // Or manually add kanban.go to backend/internal/handlers/
+    console.log(chalk_1.default.green("✓ Kanban reference app created"));
+    console.log(chalk_1.default.gray("  This app demonstrates VRP usage:"));
+    console.log(chalk_1.default.gray("  - ALL data via useViraState (no direct fetch/useState)"));
+    console.log(chalk_1.default.gray("  - Server-authoritative state"));
+    console.log(chalk_1.default.gray("  - Realtime synchronization"));
+}
+/**
+ * Создание фронтенд-проекта (Vite + Vira UI)
+ */
+async function createFrontendProject(projectPath) {
     // Базовые директории
     await fs.ensureDir(path.join(projectPath, "src", "components"));
     await fs.ensureDir(path.join(projectPath, "src", "services"));
     await fs.ensureDir(path.join(projectPath, "src", "pages"));
     await fs.ensureDir(path.join(projectPath, "src", "models"));
     await fs.ensureDir(path.join(projectPath, "src", "utils"));
+    await fs.ensureDir(path.join(projectPath, "src", "hooks"));
     // package.json
     const packageJson = {
         name: path.basename(projectPath),
@@ -152,126 +346,91 @@ async function createProjectStructure(projectPath, template) {
         },
     };
     await fs.writeJSON(path.join(projectPath, "package.json"), packageJson, { spaces: 2 });
-    // tsconfig.json
-    const tsconfig = {
-        compilerOptions: {
-            target: "ES2020",
-            module: "ESNext",
-            lib: ["ES2020", "DOM", "DOM.Iterable"],
-            jsx: "react-jsx",
-            moduleResolution: "bundler",
-            resolveJsonModule: true,
-            allowJs: true,
-            strict: true,
-            noEmit: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            paths: {
-                "@vira-ui/ui": ["./node_modules/@vira-ui/ui/src"],
-                "@vira-ui/core": ["./node_modules/@vira-ui/core/src"],
-            },
-        },
-        include: ["src"],
-    };
-    await fs.writeJSON(path.join(projectPath, "tsconfig.json"), tsconfig, { spaces: 2 });
-    // vite.config.ts
-    const viteConfig = `import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-// https://vitejs.dev/config/
-export default defineConfig({
-  plugins: [react()],
-  optimizeDeps: {
-    exclude: ['lucide-react'],
-  },
-});
-`;
-    await fs.writeFile(path.join(projectPath, "vite.config.ts"), viteConfig);
-    // index.html
-    const indexHtml = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vira App</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>
-`;
-    await fs.writeFile(path.join(projectPath, "index.html"), indexHtml);
-    // src/index.css
-    const indexCss = `* {
-  margin: 0;
-  padding: 0;
-  box-sizing: border-box;
-}
-
-body {
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-#root {
-  min-height: 100vh;
-}
-`;
-    await fs.writeFile(path.join(projectPath, "src", "index.css"), indexCss);
-    // src/main.tsx
-    const mainTsx = `import React from 'react';
-import ReactDOM from 'react-dom/client';
-import { App } from './App';
-import './index.css';
-
-const rootElement = document.getElementById('root');
-if (rootElement) {
-  ReactDOM.createRoot(rootElement).render(
-    React.createElement(React.StrictMode, null,
-      React.createElement(App)
-    )
-  );
-}
-`;
-    await fs.writeFile(path.join(projectPath, "src", "main.tsx"), mainTsx);
-    // src/App.tsx
-    const appTsx = `import React from 'react';
-import { Button } from '@vira-ui/ui';
-
-export function App() {
-  return React.createElement('div', { 
-    style: { 
-      padding: '2rem',
-      maxWidth: '800px',
-      margin: '0 auto'
-    }
-  },
-    React.createElement('h1', { 
-      style: { 
-        fontSize: '2rem',
-        fontWeight: 'bold',
-        marginBottom: '1rem'
-      }
-    }, 'Welcome to Vira!'),
-    React.createElement('p', {
-      style: {
-        marginBottom: '1rem',
-        color: '#666'
-      }
-    }, 'Start building your amazing app with Vira UI.'),
-    React.createElement(Button, {
-      preset: 'primary',
-      onClick: () => alert('Hello from Vira!')
-    }, 'Get Started')
-  );
-}
-`;
-    await fs.writeFile(path.join(projectPath, "src", "App.tsx"), appTsx);
+    await fs.writeJSON(path.join(projectPath, "tsconfig.json"), tsconfig_1.tsconfig, { spaces: 2 });
+    await fs.writeFile(path.join(projectPath, "vite.config.ts"), viteConfig_1.viteConfig);
+    await fs.writeFile(path.join(projectPath, "index.html"), indexHtml_1.indexHtml);
+    await fs.writeFile(path.join(projectPath, ".env.local"), envLocal_1.envLocal);
+    await fs.writeFile(path.join(projectPath, ".env.example"), envExample_1.envExample);
+    await fs.writeFile(path.join(projectPath, "src", "index.css"), indexCss_1.indexCss);
+    await fs.writeFile(path.join(projectPath, "src", "main.tsx"), mainTsx_1.mainTsx);
+    await fs.writeFile(path.join(projectPath, "src", "App.tsx"), appTsx_1.appTsx);
+    await fs.writeFile(path.join(projectPath, "src", "hooks", "useViraStream.ts"), useViraStream_1.useViraStream);
+    await fs.writeFile(path.join(projectPath, "src", "hooks", "useViraState.ts"), useViraState_1.useViraState);
+}
+/**
+ * Бекенд-заготовка (Go) для последующего расширения (Kafka/Redis/PG)
+ */
+async function createBackendStub(backendPath) {
+    await fs.ensureDir(backendPath);
+    await fs.ensureDir(path.join(backendPath, "cmd", "api"));
+    await fs.ensureDir(path.join(backendPath, "config"));
+    await fs.ensureDir(path.join(backendPath, "internal"));
+    await fs.ensureDir(path.join(backendPath, "internal", "middleware"));
+    await fs.ensureDir(path.join(backendPath, "internal", "config"));
+    await fs.ensureDir(path.join(backendPath, "internal", "db"));
+    await fs.ensureDir(path.join(backendPath, "internal", "cache"));
+    await fs.ensureDir(path.join(backendPath, "internal", "events"));
+    await fs.ensureDir(path.join(backendPath, "internal", "db", "gen"));
+    await fs.ensureDir(path.join(backendPath, "internal", "types"));
+    await fs.ensureDir(path.join(backendPath, "migrations"));
+    await fs.ensureDir(path.join(backendPath, "queries"));
+    await fs.writeFile(path.join(backendPath, "queries", ".gitkeep"), "");
+    await fs.writeFile(path.join(backendPath, "migrations", ".gitkeep"), "");
+    await fs.writeFile(path.join(backendPath, "go.mod"), goMod_1.goMod);
+    await fs.writeFile(path.join(backendPath, "cmd", "api", "main.go"), mainGo_1.mainGo);
+    await fs.writeFile(path.join(backendPath, "internal", "config", "config.go"), configGo_1.configGo);
+    await fs.writeFile(path.join(backendPath, "internal", "db", "db.go"), dbGo_1.dbGo);
+    await fs.writeFile(path.join(backendPath, "internal", "cache", "redis.go"), redisGo_1.redisGo);
+    await fs.writeFile(path.join(backendPath, "internal", "events", "kafka.go"), kafkaGo_1.kafkaGo);
+    await fs.writeFile(path.join(backendPath, "internal", "types", "types.go"), typesGo_1.typesGo);
+    await fs.writeFile(path.join(backendPath, "internal", "events", "channels.go"), channelHelpers_1.channelHelpers);
+    await fs.writeFile(path.join(backendPath, "internal", "events", "api.go"), eventsAPI_1.eventsAPI);
+    await fs.writeFile(path.join(backendPath, "internal", "events", "registry.go"), registryGo_1.registryGo);
+    await fs.writeFile(path.join(backendPath, "internal", "events", "state_store.go"), stateStore_1.stateStore);
+    await fs.writeFile(path.join(backendPath, "config", "app.yaml"), appYaml_1.appYaml);
+    await fs.writeFile(path.join(backendPath, "config", "db.yaml"), dbYaml_1.dbYaml);
+    await fs.writeFile(path.join(backendPath, "config", "redis.yaml"), redisYaml_1.redisYaml);
+    await fs.writeFile(path.join(backendPath, "config", "kafka.yaml"), kafkaYaml_1.kafkaYaml);
+    await fs.writeFile(path.join(backendPath, "sqlc.yaml"), sqlcYaml_1.sqlcYaml);
+    await fs.writeFile(path.join(backendPath, "Dockerfile"), dockerfile_1.dockerfile);
+    await fs.writeFile(path.join(backendPath, ".env.example"), backendEnvExample_1.backendEnvExample);
+    await fs.writeFile(path.join(backendPath, "README.md"), backendReadme_1.backendReadme);
+}
+/**
+ * Заготовка для docker-compose дев-окружения
+ */
+async function createDeployScaffold(deployPath) {
+    await fs.ensureDir(deployPath);
+    await fs.writeFile(path.join(deployPath, "docker-compose.dev.yml"), dockerCompose_1.dockerCompose);
+    await fs.writeFile(path.join(deployPath, "docker-compose.prod.yml"), dockerComposeProd_1.dockerComposeProd);
+}
+/**
+ * README монорепы с краткой схемой директорий
+ */
+async function createWorkspaceReadme(projectPath) {
+    await fs.writeFile(path.join(projectPath, "README.md"), readme_1.readme);
+}
+function printNextSteps(projectName, template) {
+    console.log(chalk_1.default.yellow(`\nNext steps:`));
+    if (template === "fullstack") {
+        console.log(`  cd ${projectName}/frontend`);
+        console.log(`  npm install`);
+        console.log(`  npm run dev`);
+        console.log(`\nUI package:`);
+        console.log(`  cd ../ui`);
+        console.log(`  npm install`);
+        console.log(`  npm run dev`);
+        console.log(`\nBackend stub:`);
+        console.log(`  cd ../backend`);
+        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`);
+        return;
+    }
+    console.log(`  cd ${projectName}`);
+    console.log(`  npm install`);
+    console.log(`  npm run dev`);
 }
 /**
  * Генерация компонента
@@ -279,18 +438,18 @@ export function App() {
 async function generateComponent(name, dir) {
     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
-}
-
-export function ${name}(props: ${name}Props) {
-  return createElement('div', { className: '${name.toLowerCase()}' },
-    // Add your content here
-  );
-}
+    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
+}
+
+export function ${name}(props: ${name}Props) {
+  return createElement('div', { className: '${name.toLowerCase()}' },
+    // Add your content here
+  );
+}
 `;
     await fs.writeFile(componentPath, componentCode);
 }
@@ -300,33 +459,33 @@ export function ${name}(props: ${name}Props) {
 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';
-
-export const ${name}Service = createViraService('${name.toLowerCase()}', () => {
-  const data = signal([]);
-  const loading = signal(false);
-  const error = signal<string | null>(null);
-
-  const fetch = async () => {
-    loading.set(true);
-    try {
-      // Add your logic here
-      // const result = await api.get('/${name.toLowerCase()}');
-      // data.set(result);
-    } catch (e) {
-      error.set(e instanceof Error ? e.message : 'Unknown error');
-    } finally {
-      loading.set(false);
-    }
-  };
-
-  return {
-    data,
-    loading,
-    error,
-    fetch,
-  };
-});
+    const serviceCode = `import { createViraService, signal } from '@vira-ui/core';
+
+export const ${name}Service = createViraService('${name.toLowerCase()}', () => {
+  const data = signal([]);
+  const loading = signal(false);
+  const error = signal<string | null>(null);
+
+  const fetch = async () => {
+    loading.set(true);
+    try {
+      // Add your logic here
+      // const result = await api.get('/${name.toLowerCase()}');
+      // data.set(result);
+    } catch (e) {
+      error.set(e instanceof Error ? e.message : 'Unknown error');
+    } finally {
+      loading.set(false);
+    }
+  };
+
+  return {
+    data,
+    loading,
+    error,
+    fetch,
+  };
+});
 `;
     await fs.writeFile(servicePath, serviceCode);
 }
@@ -336,14 +495,14 @@ 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';
-
-export function ${name}Page() {
-  return createElement('div', { className: '${name.toLowerCase()}-page' },
-    createElement('h1', null, '${name}'),
-    // Add your content here
-  );
-}
+    const pageCode = `import { createElement } from '@vira-ui/core';
+
+export function ${name}Page() {
+  return createElement('div', { className: '${name.toLowerCase()}-page' },
+    createElement('h1', null, '${name}'),
+    // Add your content here
+  );
+}
 `;
     await fs.writeFile(pagePath, pageCode);
 }
@@ -353,15 +512,15 @@ export function ${name}Page() {
 async function generateModel(name, dir) {
     const modelPath = path.join(process.cwd(), dir, "models", `${name}.ts`);
     await fs.ensureDir(path.dirname(modelPath));
-    const modelCode = `import { defineModel } from '@vira-ui/core';
-
-export const ${name}Model = defineModel({
-  // Add your fields here
-  id: {
-    type: 'string',
-    required: true,
-  },
-});
+    const modelCode = `import { defineModel } from '@vira-ui/core';
+
+export const ${name}Model = defineModel({
+  // Add your fields here
+  id: {
+    type: 'string',
+    required: true,
+  },
+});
 `;
     await fs.writeFile(modelPath, modelCode);
 }
@@ -371,13 +530,272 @@ export const ${name}Model = defineModel({
 async function generateRoute(name, dir) {
     const routePath = path.join(process.cwd(), dir, "routes", `${name}.ts`);
     await fs.ensureDir(path.dirname(routePath));
-    const routeCode = `import { reactiveRoute } from '@vira-ui/core';
-import { ${name}Page } from '../pages/${name}Page';
-
-export const ${name}Route = reactiveRoute({
-  path: '/${name.toLowerCase()}',
-  component: ${name}Page,
-});
+    const routeCode = `import { reactiveRoute } from '@vira-ui/core';
+import { ${name}Page } from '../pages/${name}Page';
+
+export const ${name}Route = reactiveRoute({
+  path: '/${name.toLowerCase()}',
+  component: ${name}Page,
+});
 `;
     await fs.writeFile(routePath, routeCode);
 }
+/**
+ * Sync TypeScript types from Go structs (scaffold-level parser)
+ */
+async function syncTypes(options) {
+    const backendPath = path.resolve(process.cwd(), options.backend);
+    const goSource = await fs.readFile(backendPath, "utf8");
+    const structs = parseGoStructs(goSource);
+    const tsContent = renderTsTypes(structs);
+    const targets = [
+        path.resolve(process.cwd(), options.frontend),
+        path.resolve(process.cwd(), options.ui),
+    ];
+    for (const target of targets) {
+        await fs.ensureDir(path.dirname(target));
+        await fs.writeFile(target, tsContent);
+    }
+    console.log(chalk_1.default.green(`✓ Synced ${structs.length} type(s) to ${options.frontend} and ${options.ui}`));
+}
+function parseGoStructs(source) {
+    const structs = [];
+    const structRegex = /type\s+(\w+)\s+struct\s*\{([^}]*)\}/gm;
+    let match;
+    while ((match = structRegex.exec(source)) !== null) {
+        const [, name, body] = match;
+        const lines = body.split("\n");
+        const fields = [];
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith("//"))
+                continue;
+            // Format: FieldName Type `json:"field"`
+            const parts = line.split("`")[0]?.trim() ?? line;
+            const tokens = parts.split(/\s+/);
+            if (tokens.length < 2)
+                continue;
+            const fieldName = tokens[0];
+            const fieldType = tokens[1];
+            let jsonTag;
+            const tagMatch = line.match(/`json:"([^"]+)"/);
+            if (tagMatch) {
+                jsonTag = tagMatch[1].replace(",omitempty", "");
+            }
+            fields.push({ name: fieldName, type: fieldType, json: jsonTag });
+        }
+        structs.push({ name, fields });
+    }
+    return structs;
+}
+function renderTsTypes(structs) {
+    const lines = [];
+    lines.push("// Auto-generated by vira sync --types. Do not edit manually.");
+    lines.push("");
+    lines.push("export type ViraMessageType =");
+    lines.push("  | 'handshake' | 'ack' | 'sub' | 'sub_ack' | 'unsub' | 'unsub_ack'");
+    lines.push("  | 'update' | 'event' | 'diff' | 'ping' | 'pong' | 'error';");
+    lines.push("");
+    lines.push("export enum ViraChannelEnum {");
+    lines.push("  User = 'user',");
+    lines.push("  Task = 'task',");
+    lines.push("  Notifications = 'notifications',");
+    lines.push("  Demo = 'demo',");
+    lines.push("}");
+    lines.push("");
+    lines.push("export type ViraChannel =");
+    lines.push("  | `${ViraChannelEnum.User}:${string}`");
+    lines.push("  | `${ViraChannelEnum.Task}:${string}`");
+    lines.push("  | `${ViraChannelEnum.Notifications}:${string}`");
+    lines.push("  | ViraChannelEnum.Demo");
+    lines.push("  | string; // fallback for custom channels");
+    lines.push("");
+    lines.push("export interface ViraDataMap {");
+    for (const s of structs) {
+        lines.push(`  ${s.name}: ${s.name};`);
+    }
+    lines.push("}");
+    lines.push("export type ViraAnyData = ViraDataMap[keyof ViraDataMap];");
+    lines.push("");
+    lines.push("export interface ViraUpdateMessage<T = ViraAnyData> { type: 'update'; channel: ViraChannel | string; data: T; ts?: number; versionNo?: number; name?: string }");
+    lines.push("export interface ViraEventMessage<T = ViraAnyData> { type: 'event'; channel: ViraChannel | string; data: T; ts?: number; versionNo?: number; name?: string }");
+    lines.push("export interface ViraDiffMessage<T = ViraAnyData> { type: 'diff'; channel: ViraChannel | string; patch: Partial<T>; ts?: number; versionNo?: number }");
+    lines.push("");
+    lines.push("// Channel helper functions");
+    lines.push("export function channelUser(id: string | number): string {");
+    lines.push(`  return \`user:\${id}\`;`);
+    lines.push("}");
+    lines.push("");
+    lines.push("export function channelTask(id: string | number): string {");
+    lines.push(`  return \`task:\${id}\`;`);
+    lines.push("}");
+    lines.push("");
+    lines.push("export function channelNotifications(userId: string | number): string {");
+    lines.push(`  return \`notifications:\${userId}\`;`);
+    lines.push("}");
+    lines.push("");
+    lines.push("export function channelCustom(name: string, key: string | number): string {");
+    lines.push(`  return \`\${name}:\${key}\`;`);
+    lines.push("}");
+    lines.push("");
+    lines.push("export type ViraMessage =");
+    lines.push("  | { type: 'handshake'; client: string; version: string; authToken?: string; session?: string; ts?: number }");
+    lines.push("  | { type: 'ack'; session: string; interval: number; ts?: number }");
+    lines.push("  | { type: 'sub'; channels: string[] }");
+    lines.push("  | { type: 'sub_ack'; channels: string[] }");
+    lines.push("  | { type: 'unsub'; channels: string[] }");
+    lines.push("  | { type: 'unsub_ack'; channels: string[] }");
+    lines.push("  | ViraUpdateMessage");
+    lines.push("  | ViraEventMessage");
+    lines.push("  | ViraDiffMessage");
+    lines.push("  | { type: 'ping'; ts?: number }");
+    lines.push("  | { type: 'pong'; ts?: number }");
+    lines.push("  | { type: 'error'; name?: string; message?: string };");
+    lines.push("");
+    for (const s of structs) {
+        lines.push(`export interface ${s.name} {`);
+        for (const f of s.fields) {
+            const tsType = goTypeToTs(f.type);
+            const jsonName = f.json || toCamel(f.name);
+            lines.push(`  ${jsonName}: ${tsType};`);
+        }
+        lines.push("}");
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function goTypeToTs(goType) {
+    // Strip package prefix
+    const clean = goType.replace(/^[a-zA-Z_]+\./, "");
+    // Slice/array
+    if (clean.startsWith("[]")) {
+        const inner = goTypeToTs(clean.slice(2));
+        return `${inner}[]`;
+    }
+    switch (clean) {
+        case "string":
+        case "uuid":
+            return "string";
+        case "int":
+        case "int32":
+        case "int64":
+        case "uint":
+        case "uint32":
+        case "uint64":
+        case "float32":
+        case "float64":
+            return "number";
+        case "bool":
+            return "boolean";
+        case "Time":
+            return "string";
+        default:
+            return "any";
+    }
+}
+function toCamel(name) {
+    if (!name)
+        return name;
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+/**
+ * Go HTTP handler scaffold
+ */
+async function generateGoHandler(name, dir) {
+    const safeName = name.toLowerCase();
+    const handlerName = capitalize(name);
+    const targetDir = path.join(process.cwd(), dir);
+    await fs.ensureDir(targetDir);
+    const handlerCode = `package handlers
+
+import (
+  "encoding/json"
+  "net/http"
+)
+
+type ${handlerName}Response struct {
+  Message string \`json:"message"\`
+}
+
+// ${handlerName} handles GET /${safeName}
+func ${handlerName}(w http.ResponseWriter, r *http.Request) {
+  w.Header().Set("Content-Type", "application/json")
+  _ = json.NewEncoder(w).Encode(${handlerName}Response{
+    Message: "${handlerName} handler ok",
+  })
+}
+`;
+    await fs.writeFile(path.join(targetDir, `${safeName}.go`), handlerCode);
+}
+/**
+ * Go model scaffold
+ */
+async function generateGoModel(name, dir) {
+    const modelName = capitalize(name);
+    const targetDir = path.join(process.cwd(), dir);
+    await fs.ensureDir(targetDir);
+    const modelCode = `package models
+
+import "time"
+
+type ${modelName} struct {
+  ID        string    \`db:"id"\`
+  CreatedAt time.Time \`db:"created_at"\`
+  UpdatedAt time.Time \`db:"updated_at"\`
+}
+`;
+    await fs.writeFile(path.join(targetDir, `${modelName}.go`), modelCode);
+}
+/**
+ * SQL migration scaffold (timestamped up/down)
+ */
+async function generateMigration(name, dir) {
+    const timestamp = new Date()
+        .toISOString()
+        .replace(/[-:T.Z]/g, "")
+        .slice(0, 14);
+    const baseName = `${timestamp}_${name}`;
+    const targetDir = path.join(process.cwd(), dir);
+    await fs.ensureDir(targetDir);
+    const upPath = path.join(targetDir, `${baseName}.up.sql`);
+    const downPath = path.join(targetDir, `${baseName}.down.sql`);
+    const upTemplate = `-- +goose Up
+-- TODO: add migration SQL here
+`;
+    const downTemplate = `-- +goose Down
+-- TODO: rollback SQL here
+`;
+    await fs.writeFile(upPath, upTemplate);
+    await fs.writeFile(downPath, downTemplate);
+}
+async function generateEventHandler(name, dir) {
+    const targetDir = path.join(process.cwd(), dir);
+    await fs.ensureDir(targetDir);
+    const fileName = name.replace(/[^a-zA-Z0-9]+/g, "_");
+    const content = (0, eventHandlerTemplate_1.eventHandlerTemplate)(name);
+    await fs.writeFile(path.join(targetDir, `${fileName}.go`), content);
+    // Also create registry entry file (one per event) to auto-register
+    const handlerFunc = toPascal(name);
+    const registryFile = path.join(targetDir, `registry_${fileName}.go`);
+    if (!(await fs.pathExists(registryFile))) {
+        const registryContent = `package events
+
+func init() {
+  Register("${name}", ${handlerFunc})
+}
+`;
+        await fs.writeFile(registryFile, registryContent);
+    }
+}
+function capitalize(value) {
+    if (!value)
+        return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function toPascal(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join("");
+}