@openwebf/webf 0.23.10 → 0.24.1

package/README.md

@@ -10,6 +10,14 @@ npm install -g @openwebf/webf
 
 ## Usage
 
+### Initialize Claude Code Skills
+
+The `webf agents init` command injects WebF Claude Code skills (from `@openwebf/claude-code-skills`) into your project and updates `CLAUDE.md` to reference them.
+
+```bash
+webf agents init [project-dir]
+```
+
 ### Generate Code
 
 The `webf codegen` command generates Dart abstract classes and React/Vue components from TypeScript definitions. It automatically creates a project if needed.

package/bin/webf.js

@@ -2,7 +2,7 @@
 
 const { Command } = require('commander');
 const version = require('../package.json').version;
-const { generateCommand, generateModuleCommand } = require('../dist/commands');
+const { generateCommand, generateModuleCommand, agentsInitCommand } = require('../dist/commands');
 
 const program = new Command();
 
@@ -35,4 +35,12 @@ program
   .description('Generate NPM package and Dart bindings for a WebF module from TypeScript interfaces (*.module.d.ts)')
   .action(generateModuleCommand);
 
+const agents = program.command('agents').description('Manage Claude Code agent configs');
+
+agents
+  .command('init')
+  .argument('[projectDir]', 'Target project directory', '.')
+  .description('Initialize Claude Code skills config for a project')
+  .action(agentsInitCommand);
+
 program.parse();

package/dist/agents.js

@@ -0,0 +1,245 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsInitCommand = agentsInitCommand;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const WEBF_AGENTS_BLOCK_START = '<!-- webf-agents:init start -->';
+const WEBF_AGENTS_BLOCK_END = '<!-- webf-agents:init end -->';
+function ensureDirSync(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function readFileIfExists(filePath) {
+    try {
+        return fs_1.default.readFileSync(filePath);
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function backupFileSync(filePath) {
+    const timestamp = new Date()
+        .toISOString()
+        .replace(/[:.]/g, '')
+        .replace('T', '')
+        .replace('Z', 'Z');
+    const backupPath = `${filePath}.bak.${timestamp}`;
+    fs_1.default.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+function copyFileWithBackupSync(srcPath, destPath) {
+    const src = fs_1.default.readFileSync(srcPath);
+    const dest = readFileIfExists(destPath);
+    if (dest && Buffer.compare(src, dest) === 0)
+        return { changed: false, backupPath: null };
+    ensureDirSync(path_1.default.dirname(destPath));
+    let backupPath = null;
+    if (dest) {
+        backupPath = backupFileSync(destPath);
+    }
+    fs_1.default.writeFileSync(destPath, src);
+    return { changed: true, backupPath };
+}
+function copyDirRecursiveSync(srcDir, destDir, stats) {
+    ensureDirSync(destDir);
+    const entries = fs_1.default.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(srcDir, entry.name);
+        const destPath = path_1.default.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursiveSync(srcPath, destPath, stats);
+            continue;
+        }
+        if (entry.isFile()) {
+            const { changed, backupPath } = copyFileWithBackupSync(srcPath, destPath);
+            if (changed)
+                stats.filesWritten += 1;
+            else
+                stats.filesUnchanged += 1;
+            if (backupPath)
+                stats.backupsCreated += 1;
+        }
+    }
+}
+function listFilesRecursiveSync(dirPath) {
+    const out = [];
+    const entries = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...listFilesRecursiveSync(entryPath));
+            continue;
+        }
+        if (entry.isFile())
+            out.push(entryPath);
+    }
+    return out;
+}
+function toPosixRelativePath(fromDir, absolutePath) {
+    const rel = path_1.default.relative(fromDir, absolutePath);
+    return rel.split(path_1.default.sep).join('/');
+}
+function parseSkillFrontmatter(skillMd) {
+    var _a;
+    const trimmed = skillMd.trimStart();
+    if (!trimmed.startsWith('---'))
+        return {};
+    const endIndex = trimmed.indexOf('\n---', 3);
+    if (endIndex === -1)
+        return {};
+    const fm = trimmed.slice(3, endIndex).trim();
+    try {
+        const parsed = (_a = yaml_1.default.parse(fm)) !== null && _a !== void 0 ? _a : {};
+        return { name: parsed === null || parsed === void 0 ? void 0 : parsed.name, description: parsed === null || parsed === void 0 ? void 0 : parsed.description };
+    }
+    catch (_b) {
+        return {};
+    }
+}
+function updateOrAppendMarkedBlock(existing, newBlock) {
+    const startIndex = existing.indexOf(WEBF_AGENTS_BLOCK_START);
+    const endIndex = existing.indexOf(WEBF_AGENTS_BLOCK_END);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        const before = existing.slice(0, startIndex).trimEnd();
+        const after = existing.slice(endIndex + WEBF_AGENTS_BLOCK_END.length).trimStart();
+        const next = [before, newBlock.trim(), after].filter(Boolean).join('\n\n');
+        return { content: next + '\n', action: 'replaced' };
+    }
+    const content = existing.trimEnd();
+    return { content: (content ? content + '\n\n' : '') + newBlock.trim() + '\n', action: 'appended' };
+}
+function buildClaudeBlock(sourcePackageName, sourcePackageVersion, skills) {
+    const lines = [];
+    lines.push(WEBF_AGENTS_BLOCK_START);
+    lines.push('## WebF Claude Code Skills');
+    lines.push('');
+    lines.push(`Source: \`${sourcePackageName}@${sourcePackageVersion}\``);
+    lines.push('');
+    lines.push('### Skills');
+    for (const skill of skills) {
+        const desc = skill.description ? ` — ${skill.description}` : '';
+        lines.push(`- \`${skill.name}\`${desc} (\`${skill.skillFileRelativePath}\`)`);
+    }
+    const anyReferences = skills.some(s => s.referenceRelativePaths.length > 0);
+    if (anyReferences) {
+        lines.push('');
+        lines.push('### References');
+        for (const skill of skills) {
+            if (skill.referenceRelativePaths.length === 0)
+                continue;
+            const refs = skill.referenceRelativePaths.map(r => `\`${r}\``).join(', ');
+            lines.push(`- \`${skill.name}\`: ${refs}`);
+        }
+    }
+    lines.push(WEBF_AGENTS_BLOCK_END);
+    return lines.join('\n');
+}
+function resolveSkillsPackageRoot() {
+    var _a, _b;
+    const packageJsonPath = require.resolve('@openwebf/claude-code-skills/package.json');
+    const packageRoot = path_1.default.dirname(packageJsonPath);
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+    return {
+        packageRoot,
+        packageName: (_a = packageJson === null || packageJson === void 0 ? void 0 : packageJson.name) !== null && _a !== void 0 ? _a : '@openwebf/claude-code-skills',
+        packageVersion: (_b = packageJson === null || packageJson === void 0 ? void 0 : packageJson.version) !== null && _b !== void 0 ? _b : 'unknown',
+    };
+}
+function listSkillDirectories(skillsPackageRoot) {
+    const entries = fs_1.default.readdirSync(skillsPackageRoot, { withFileTypes: true });
+    const dirs = entries
+        .filter(e => e.isDirectory())
+        .map(e => e.name)
+        .filter(name => fs_1.default.existsSync(path_1.default.join(skillsPackageRoot, name, 'SKILL.md')))
+        .sort();
+    return dirs;
+}
+function collectSkillInfo(projectRoot, skillsDir, skillDirectoryName) {
+    var _a;
+    const skillDirAbs = path_1.default.join(skillsDir, skillDirectoryName);
+    const skillMdAbs = path_1.default.join(skillDirAbs, 'SKILL.md');
+    const skillMd = fs_1.default.readFileSync(skillMdAbs, 'utf-8');
+    const fm = parseSkillFrontmatter(skillMd);
+    const referenceRelativePaths = [];
+    const files = listFilesRecursiveSync(skillDirAbs);
+    for (const fileAbs of files) {
+        if (path_1.default.basename(fileAbs) === 'SKILL.md')
+            continue;
+        referenceRelativePaths.push(toPosixRelativePath(projectRoot, fileAbs));
+    }
+    referenceRelativePaths.sort();
+    return {
+        directoryName: skillDirectoryName,
+        name: (_a = fm.name) !== null && _a !== void 0 ? _a : skillDirectoryName,
+        description: fm.description,
+        skillFileRelativePath: toPosixRelativePath(projectRoot, skillMdAbs),
+        referenceRelativePaths,
+    };
+}
+function agentsInitCommand(projectDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const startedAt = Date.now();
+        const resolvedProjectDir = path_1.default.resolve(process.cwd(), projectDir || '.');
+        const claudeMdPath = path_1.default.join(resolvedProjectDir, 'CLAUDE.md');
+        const claudeDir = path_1.default.join(resolvedProjectDir, '.claude');
+        const projectSkillsDir = path_1.default.join(claudeDir, 'skills');
+        const hasClaudeMd = fs_1.default.existsSync(claudeMdPath);
+        const hasClaudeDir = fs_1.default.existsSync(claudeDir);
+        const isNewProject = !hasClaudeMd && !hasClaudeDir;
+        console.log('webf agents init');
+        console.log(`Project: ${resolvedProjectDir}`);
+        if (isNewProject) {
+            console.log('Detected: no CLAUDE.md and no .claude/ (new project)');
+        }
+        else {
+            console.log(`Detected: CLAUDE.md=${hasClaudeMd ? 'yes' : 'no'}, .claude/=${hasClaudeDir ? 'yes' : 'no'} (existing project)`);
+        }
+        const { packageRoot, packageName, packageVersion } = resolveSkillsPackageRoot();
+        const skillDirectories = listSkillDirectories(packageRoot);
+        if (skillDirectories.length === 0) {
+            throw new Error(`No skills found in ${packageName} (resolved at ${packageRoot}).`);
+        }
+        console.log(`Skills source: ${packageName}@${packageVersion}`);
+        console.log(`Skills destination: ${toPosixRelativePath(resolvedProjectDir, projectSkillsDir)}`);
+        ensureDirSync(projectSkillsDir);
+        const copyStats = { filesWritten: 0, filesUnchanged: 0, backupsCreated: 0 };
+        for (const skillDirName of skillDirectories) {
+            const srcSkillDir = path_1.default.join(packageRoot, skillDirName);
+            const destSkillDir = path_1.default.join(projectSkillsDir, skillDirName);
+            copyDirRecursiveSync(srcSkillDir, destSkillDir, copyStats);
+        }
+        const installedSkills = skillDirectories.map(skillDirName => collectSkillInfo(resolvedProjectDir, projectSkillsDir, skillDirName));
+        const block = buildClaudeBlock(packageName, packageVersion, installedSkills);
+        if (isNewProject) {
+            const initial = ['# Claude Code', '', block, ''].join('\n');
+            fs_1.default.writeFileSync(claudeMdPath, initial, 'utf-8');
+            console.log(`Created ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+        }
+        else {
+            const existing = (_b = (_a = readFileIfExists(claudeMdPath)) === null || _a === void 0 ? void 0 : _a.toString('utf-8')) !== null && _b !== void 0 ? _b : '';
+            const { content, action } = updateOrAppendMarkedBlock(existing, block);
+            fs_1.default.writeFileSync(claudeMdPath, content, 'utf-8');
+            console.log(`${action === 'replaced' ? 'Updated' : 'Appended'} WebF skills block in ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+        }
+        const versionFilePath = path_1.default.join(claudeDir, 'webf-claude-code-skills.version');
+        fs_1.default.writeFileSync(versionFilePath, `${packageName}@${packageVersion}${os_1.default.EOL}`, 'utf-8');
+        console.log(`Wrote ${toPosixRelativePath(resolvedProjectDir, versionFilePath)}`);
+        console.log(`Installed ${installedSkills.length} skills (${copyStats.filesWritten} files written, ${copyStats.filesUnchanged} unchanged, ${copyStats.backupsCreated} backups) in ${Date.now() - startedAt}ms`);
+    });
+}

package/dist/commands.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsInitCommand = void 0;
 exports.generateCommand = generateCommand;
 exports.generateModuleCommand = generateModuleCommand;
 const child_process_1 = require("child_process");
@@ -20,10 +21,13 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
 const module_1 = require("./module");
+const peerDeps_1 = require("./peerDeps");
 const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const yaml_1 = __importDefault(require("yaml"));
+const agents_1 = require("./agents");
+Object.defineProperty(exports, "agentsInitCommand", { enumerable: true, get: function () { return agents_1.agentsInitCommand; } });
 /**
  * Sanitize a package name to comply with npm naming rules
  * NPM package name rules:
@@ -350,7 +354,8 @@ function createCommand(target, options) {
             // Do not overwrite existing index.ts created by the user
             // Leave merge to the codegen step which appends exports safely
         }
-        (0, child_process_1.spawnSync)(NPM, ['install'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -369,11 +374,8 @@ function createCommand(target, options) {
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
         writeFileIfChanged(gitignorePath, gitignoreContent);
-        (0, child_process_1.spawnSync)(NPM, ['install', '@openwebf/webf-enterprise-typings'], {
-            cwd: target,
-            stdio: 'inherit'
-        });
-        (0, child_process_1.spawnSync)(NPM, ['install', 'vue', '-D'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -1003,7 +1005,7 @@ function ensureInitialized(targetPath) {
 }
 function buildPackage(packagePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b, _c;
         const packageJsonPath = path_1.default.join(packagePath, 'package.json');
         if (!fs_1.default.existsSync(packageJsonPath)) {
             // Skip the error in test environment to avoid console warnings
@@ -1015,6 +1017,91 @@ function buildPackage(packagePath) {
         const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
         const packageName = packageJson.name;
         const packageVersion = packageJson.version;
+        function getInstalledPackageJsonPath(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts, 'package.json');
+        }
+        function getInstalledPackageDir(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts);
+        }
+        function findUp(startDir, relativePathToFind) {
+            let dir = path_1.default.resolve(startDir);
+            while (true) {
+                const candidate = path_1.default.join(dir, relativePathToFind);
+                if (fs_1.default.existsSync(candidate))
+                    return candidate;
+                const parent = path_1.default.dirname(dir);
+                if (parent === dir)
+                    return null;
+                dir = parent;
+            }
+        }
+        function ensurePeerDependencyAvailableForBuild(peerName) {
+            var _a, _b;
+            const installedPkgJson = getInstalledPackageJsonPath(peerName);
+            if (fs_1.default.existsSync(installedPkgJson))
+                return;
+            const peerRange = (_a = packageJson.peerDependencies) === null || _a === void 0 ? void 0 : _a[peerName];
+            const localMap = {
+                '@openwebf/react-core-ui': path_1.default.join('packages', 'react-core-ui'),
+                '@openwebf/vue-core-ui': path_1.default.join('packages', 'vue-core-ui'),
+            };
+            let installSpec = null;
+            const localRel = localMap[peerName];
+            if (localRel) {
+                const localPath = findUp(process.cwd(), localRel);
+                if (localPath) {
+                    if (!(0, peerDeps_1.isPackageTypesReady)(localPath)) {
+                        const localPkgJsonPath = path_1.default.join(localPath, 'package.json');
+                        if (fs_1.default.existsSync(localPkgJsonPath)) {
+                            const localPkgJson = (0, peerDeps_1.readJsonFile)(localPkgJsonPath);
+                            if ((_b = localPkgJson.scripts) === null || _b === void 0 ? void 0 : _b.build) {
+                                if (process.env.WEBF_CODEGEN_BUILD_LOCAL_PEERS !== '1') {
+                                    console.warn(`\n⚠️  Local ${peerName} found at ${localPath} but type declarations are missing; falling back to registry install.`);
+                                }
+                                else {
+                                    console.log(`\n🔧 Local ${peerName} found at ${localPath} but build artifacts are missing; building it for DTS...`);
+                                    const buildLocalResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
+                                        cwd: localPath,
+                                        stdio: 'inherit'
+                                    });
+                                    if (buildLocalResult.status === 0) {
+                                        if ((0, peerDeps_1.isPackageTypesReady)(localPath)) {
+                                            installSpec = localPath;
+                                        }
+                                        else {
+                                            console.warn(`\n⚠️  Built local ${peerName} but type declarations are still missing; falling back to registry install.`);
+                                        }
+                                    }
+                                    else {
+                                        console.warn(`\n⚠️  Failed to build local ${peerName}; falling back to registry install.`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        installSpec = localPath;
+                    }
+                }
+            }
+            if (!installSpec) {
+                installSpec = peerRange ? `${peerName}@${peerRange}` : peerName;
+            }
+            console.log(`\n📦 Installing peer dependency for build: ${peerName}...`);
+            const installResult = (0, child_process_1.spawnSync)(NPM, ['install', '--no-save', installSpec], {
+                cwd: packagePath,
+                stdio: 'inherit'
+            });
+            if (installResult.status !== 0) {
+                throw new Error(`Failed to install peer dependency for build: ${peerName}`);
+            }
+            const installedTypesFile = (0, peerDeps_1.getPackageTypesFileFromDir)(getInstalledPackageDir(peerName));
+            if (installedTypesFile && !fs_1.default.existsSync(installedTypesFile)) {
+                throw new Error(`Peer dependency ${peerName} was installed but type declarations were not found at ${installedTypesFile}`);
+            }
+        }
         // Check if node_modules exists
         const nodeModulesPath = path_1.default.join(packagePath, 'node_modules');
         if (!fs_1.default.existsSync(nodeModulesPath)) {
@@ -1035,6 +1122,13 @@ function buildPackage(packagePath) {
         }
         // Check if package has a build script
         if ((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.build) {
+            // DTS build needs peer deps present locally to resolve types (even though they are not bundled).
+            if ((_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b['@openwebf/react-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/react-core-ui');
+            }
+            if ((_c = packageJson.peerDependencies) === null || _c === void 0 ? void 0 : _c['@openwebf/vue-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/vue-core-ui');
+            }
             console.log(`\nBuilding ${packageName}@${packageVersion}...`);
             const buildResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
                 cwd: packagePath,

package/dist/generator.js

@@ -378,11 +378,8 @@ function reactGen(_a) {
                 (0, logger_1.warn)(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
             }
         }
-        (0, logger_1.timeEnd)('reactGen');
-        (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
-        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
-        (0, logger_1.info)('You can now import these components in your React project.');
-        // Aggregate standalone type declarations (consts/enums/type aliases) into a single types.ts
+        // Always generate src/types.ts so generated components can safely import it.
+        // When there are no standalone declarations, emit an empty module (`export {};`).
         try {
             const consts = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.ConstObject));
             const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.EnumObject));
@@ -395,38 +392,38 @@ function reactGen(_a) {
             typeAliases.forEach(t => { if (!typeAliasMap.has(t.name))
                 typeAliasMap.set(t.name, t); });
             const hasAny = constMap.size > 0 || enums.length > 0 || typeAliasMap.size > 0;
-            if (hasAny) {
-                const constDecl = Array.from(constMap.values())
-                    .map(c => `export declare const ${c.name}: ${c.type};`)
-                    .join('\n');
-                const enumDecl = enums
-                    .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
-                    .join('\n');
-                const typeAliasDecl = Array.from(typeAliasMap.values())
-                    .map(t => `export type ${t.name} = ${t.type};`)
-                    .join('\n');
-                const typesContent = [
-                    '/* Generated by WebF CLI - aggregated type declarations */',
-                    typeAliasDecl,
-                    constDecl,
-                    enumDecl,
-                    ''
-                ].filter(Boolean).join('\n');
-                const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
-                if (writeFileIfChanged(typesPath, typesContent)) {
-                    filesChanged++;
-                    (0, logger_1.debug)(`Generated: src/types.ts`);
-                    try {
-                        const constNames = Array.from(constMap.keys());
-                        const aliasNames = Array.from(typeAliasMap.keys());
-                        const enumNames = enums.map(e => e.name);
-                        (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
-                        (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
-                    }
-                    catch (_b) { }
+            const constDecl = Array.from(constMap.values())
+                .map(c => `export declare const ${c.name}: ${c.type};`)
+                .join('\n');
+            const enumDecl = enums
+                .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
+                .join('\n');
+            const typeAliasDecl = Array.from(typeAliasMap.values())
+                .map(t => `export type ${t.name} = ${t.type};`)
+                .join('\n');
+            const typesContent = [
+                '/* Generated by WebF CLI - aggregated type declarations */',
+                hasAny ? typeAliasDecl : '',
+                hasAny ? constDecl : '',
+                hasAny ? enumDecl : '',
+                hasAny ? '' : 'export {};',
+                ''
+            ].filter(Boolean).join('\n');
+            const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
+            if (writeFileIfChanged(typesPath, typesContent)) {
+                filesChanged++;
+                (0, logger_1.debug)(`Generated: src/types.ts`);
+                try {
+                    const constNames = Array.from(constMap.keys());
+                    const aliasNames = Array.from(typeAliasMap.keys());
+                    const enumNames = enums.map(e => e.name);
+                    (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+                    (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
                 }
-                // Ensure index.ts re-exports these types so consumers get them on import.
-                const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+                catch (_b) { }
+            }
+            // Only re-export from index.ts when there are actual declarations to surface.
+            if (hasAny) {
                 try {
                     let current = '';
                     if (fs_1.default.existsSync(indexFilePath)) {
@@ -447,6 +444,10 @@ function reactGen(_a) {
         catch (e) {
             (0, logger_1.warn)('Failed to generate aggregated React types');
         }
+        (0, logger_1.timeEnd)('reactGen');
+        (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
+        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
+        (0, logger_1.info)('You can now import these components in your React project.');
     });
 }
 function vueGen(_a) {

package/dist/module.js

@@ -247,14 +247,14 @@ function mapTsParamTypeToDart(typeText, optionNames) {
     }
     return { dartType: 'dynamic', isByteData: false };
 }
-function mapTsPropertyTypeToDart(type) {
+function mapTsPropertyTypeToDart(type, optional) {
     switch (type.kind) {
         case typescript_1.default.SyntaxKind.StringKeyword:
-            return 'String?';
+            return optional ? 'String?' : 'String';
         case typescript_1.default.SyntaxKind.NumberKeyword:
-            return 'num?';
+            return optional ? 'num?' : 'num';
         case typescript_1.default.SyntaxKind.BooleanKeyword:
-            return 'bool?';
+            return optional ? 'bool?' : 'bool';
         default:
             return 'dynamic';
     }
@@ -288,28 +288,52 @@ function buildDartBindings(def, command) {
                 continue;
             const key = member.name.getText(def.sourceFile).replace(/['"]/g, '');
             const fieldName = key;
-            const dartType = member.type ? mapTsPropertyTypeToDart(member.type) : 'dynamic';
-            propInfos.push({ fieldName, key, dartType });
+            const optional = !!member.questionToken;
+            const dartType = member.type ? mapTsPropertyTypeToDart(member.type, optional) : 'dynamic';
+            propInfos.push({ fieldName, key, dartType, optional });
         }
         lines.push(`class ${name} {`);
         for (const prop of propInfos) {
             lines.push(`  final ${prop.dartType} ${prop.fieldName};`);
         }
         lines.push('');
-        const ctorParams = propInfos.map(p => `this.${p.fieldName}`).join(', ');
+        const ctorParams = propInfos.map(p => {
+            if (p.optional || p.dartType === 'dynamic') {
+                return `this.${p.fieldName}`;
+            }
+            return `required this.${p.fieldName}`;
+        }).join(', ');
         lines.push(`  const ${name}({${ctorParams}});`);
         lines.push('');
         lines.push(`  factory ${name}.fromMap(Map<String, dynamic> map) {`);
         lines.push(`    return ${name}(`);
         for (const prop of propInfos) {
-            if (prop.dartType.startsWith('String')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString(),`);
+            const isString = prop.dartType.startsWith('String');
+            const isBool = prop.dartType.startsWith('bool');
+            const isNum = prop.dartType.startsWith('num');
+            if (isString) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString(),`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}']?.toString() ?? '',`);
+                }
             }
-            else if (prop.dartType.startsWith('bool')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`);
+            else if (isBool) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : false,`);
+                }
             }
-            else if (prop.dartType.startsWith('num')) {
-                lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`);
+            else if (isNum) {
+                if (prop.optional) {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`);
+                }
+                else {
+                    lines.push(`      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : 0,`);
+                }
             }
             else {
                 lines.push(`      ${prop.fieldName}: map['${prop.key}'],`);
@@ -321,7 +345,12 @@ function buildDartBindings(def, command) {
         lines.push('  Map<String, dynamic> toMap() {');
         lines.push('    final map = <String, dynamic>{};');
         for (const prop of propInfos) {
-            lines.push(`    if (${prop.fieldName} != null) { map['${prop.key}'] = ${prop.fieldName}; }`);
+            if (!prop.optional && (prop.dartType === 'String' || prop.dartType === 'bool' || prop.dartType === 'num')) {
+                lines.push(`    map['${prop.key}'] = ${prop.fieldName};`);
+            }
+            else {
+                lines.push(`    if (${prop.fieldName} != null) { map['${prop.key}'] = ${prop.fieldName}; }`);
+            }
         }
         lines.push('    return map;');
         lines.push('  }');