@openwebf/webf 0.23.10 → 0.24.1

package/src/agents.ts

@@ -0,0 +1,267 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import yaml from 'yaml';
+
+type SkillInfo = {
+  directoryName: string;
+  name: string;
+  description?: string;
+  skillFileRelativePath: string;
+  referenceRelativePaths: string[];
+};
+
+type CopyStats = {
+  filesWritten: number;
+  filesUnchanged: number;
+  backupsCreated: number;
+};
+
+const WEBF_AGENTS_BLOCK_START = '<!-- webf-agents:init start -->';
+const WEBF_AGENTS_BLOCK_END = '<!-- webf-agents:init end -->';
+
+function ensureDirSync(dirPath: string) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readFileIfExists(filePath: string): Buffer | null {
+  try {
+    return fs.readFileSync(filePath);
+  } catch (error: any) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function backupFileSync(filePath: string) {
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[:.]/g, '')
+    .replace('T', '')
+    .replace('Z', 'Z');
+  const backupPath = `${filePath}.bak.${timestamp}`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+function copyFileWithBackupSync(srcPath: string, destPath: string) {
+  const src = fs.readFileSync(srcPath);
+  const dest = readFileIfExists(destPath);
+
+  if (dest && Buffer.compare(src, dest) === 0) return { changed: false, backupPath: null as string | null };
+
+  ensureDirSync(path.dirname(destPath));
+  let backupPath: string | null = null;
+  if (dest) {
+    backupPath = backupFileSync(destPath);
+  }
+  fs.writeFileSync(destPath, src);
+  return { changed: true, backupPath };
+}
+
+function copyDirRecursiveSync(srcDir: string, destDir: string, stats: CopyStats) {
+  ensureDirSync(destDir);
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.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: string): string[] {
+  const out: string[] = [];
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listFilesRecursiveSync(entryPath));
+      continue;
+    }
+    if (entry.isFile()) out.push(entryPath);
+  }
+  return out;
+}
+
+function toPosixRelativePath(fromDir: string, absolutePath: string) {
+  const rel = path.relative(fromDir, absolutePath);
+  return rel.split(path.sep).join('/');
+}
+
+function parseSkillFrontmatter(skillMd: string): { name?: string; description?: string } {
+  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 = yaml.parse(fm) ?? {};
+    return { name: parsed?.name, description: parsed?.description };
+  } catch {
+    return {};
+  }
+}
+
+function updateOrAppendMarkedBlock(existing: string, newBlock: string): { content: string; action: 'replaced' | 'appended' } {
+  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: string, sourcePackageVersion: string, skills: SkillInfo[]) {
+  const lines: string[] = [];
+  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() {
+  const packageJsonPath = require.resolve('@openwebf/claude-code-skills/package.json');
+  const packageRoot = path.dirname(packageJsonPath);
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  return {
+    packageRoot,
+    packageName: packageJson?.name ?? '@openwebf/claude-code-skills',
+    packageVersion: packageJson?.version ?? 'unknown',
+  };
+}
+
+function listSkillDirectories(skillsPackageRoot: string) {
+  const entries = fs.readdirSync(skillsPackageRoot, { withFileTypes: true });
+  const dirs = entries
+    .filter(e => e.isDirectory())
+    .map(e => e.name)
+    .filter(name => fs.existsSync(path.join(skillsPackageRoot, name, 'SKILL.md')))
+    .sort();
+  return dirs;
+}
+
+function collectSkillInfo(projectRoot: string, skillsDir: string, skillDirectoryName: string): SkillInfo {
+  const skillDirAbs = path.join(skillsDir, skillDirectoryName);
+  const skillMdAbs = path.join(skillDirAbs, 'SKILL.md');
+  const skillMd = fs.readFileSync(skillMdAbs, 'utf-8');
+  const fm = parseSkillFrontmatter(skillMd);
+
+  const referenceRelativePaths: string[] = [];
+  const files = listFilesRecursiveSync(skillDirAbs);
+  for (const fileAbs of files) {
+    if (path.basename(fileAbs) === 'SKILL.md') continue;
+    referenceRelativePaths.push(toPosixRelativePath(projectRoot, fileAbs));
+  }
+  referenceRelativePaths.sort();
+
+  return {
+    directoryName: skillDirectoryName,
+    name: fm.name ?? skillDirectoryName,
+    description: fm.description,
+    skillFileRelativePath: toPosixRelativePath(projectRoot, skillMdAbs),
+    referenceRelativePaths,
+  };
+}
+
+async function agentsInitCommand(projectDir: string): Promise<void> {
+  const startedAt = Date.now();
+  const resolvedProjectDir = path.resolve(process.cwd(), projectDir || '.');
+  const claudeMdPath = path.join(resolvedProjectDir, 'CLAUDE.md');
+  const claudeDir = path.join(resolvedProjectDir, '.claude');
+  const projectSkillsDir = path.join(claudeDir, 'skills');
+
+  const hasClaudeMd = fs.existsSync(claudeMdPath);
+  const hasClaudeDir = fs.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: CopyStats = { filesWritten: 0, filesUnchanged: 0, backupsCreated: 0 };
+  for (const skillDirName of skillDirectories) {
+    const srcSkillDir = path.join(packageRoot, skillDirName);
+    const destSkillDir = path.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.writeFileSync(claudeMdPath, initial, 'utf-8');
+    console.log(`Created ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+  } else {
+    const existing = readFileIfExists(claudeMdPath)?.toString('utf-8') ?? '';
+    const { content, action } = updateOrAppendMarkedBlock(existing, block);
+    fs.writeFileSync(claudeMdPath, content, 'utf-8');
+    console.log(`${action === 'replaced' ? 'Updated' : 'Appended'} WebF skills block in ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+  }
+
+  const versionFilePath = path.join(claudeDir, 'webf-claude-code-skills.version');
+  fs.writeFileSync(versionFilePath, `${packageName}@${packageVersion}${os.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`
+  );
+}
+
+export { agentsInitCommand };

package/src/commands.ts

@@ -4,10 +4,12 @@ import path from 'path';
 import os from 'os';
 import { dartGen, reactGen, vueGen } from './generator';
 import { generateModuleArtifacts } from './module';
+import { getPackageTypesFileFromDir, isPackageTypesReady, readJsonFile } from './peerDeps';
 import { globSync } from 'glob';
 import _ from 'lodash';
 import inquirer from 'inquirer';
 import yaml from 'yaml';
+import { agentsInitCommand } from './agents';
 
 interface GenerateOptions {
   flutterPackageSrc?: string;
@@ -441,7 +443,8 @@ function createCommand(target: string, options: { framework: string; packageName
       // Leave merge to the codegen step which appends exports safely
     }
 
-    spawnSync(NPM, ['install'], {
+    // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+    spawnSync(NPM, ['install', '--production=false'], {
       cwd: target,
       stdio: 'inherit'
     });
@@ -463,12 +466,8 @@ function createCommand(target: string, options: { framework: string; packageName
     const gitignoreContent = _.template(gitignore)({});
     writeFileIfChanged(gitignorePath, gitignoreContent);
 
-    spawnSync(NPM, ['install', '@openwebf/webf-enterprise-typings'], {
-      cwd: target,
-      stdio: 'inherit'
-    });
-
-    spawnSync(NPM, ['install', 'vue', '-D'], {
+    // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+    spawnSync(NPM, ['install', '--production=false'], {
       cwd: target,
       stdio: 'inherit'
     });
@@ -1179,6 +1178,101 @@ async function buildPackage(packagePath: string): Promise<void> {
   const packageName = packageJson.name;
   const packageVersion = packageJson.version;
 
+  function getInstalledPackageJsonPath(pkgName: string): string {
+    const parts = pkgName.split('/');
+    return path.join(packagePath, 'node_modules', ...parts, 'package.json');
+  }
+
+  function getInstalledPackageDir(pkgName: string): string {
+    const parts = pkgName.split('/');
+    return path.join(packagePath, 'node_modules', ...parts);
+  }
+
+  function findUp(startDir: string, relativePathToFind: string): string | null {
+    let dir = path.resolve(startDir);
+    while (true) {
+      const candidate = path.join(dir, relativePathToFind);
+      if (fs.existsSync(candidate)) return candidate;
+      const parent = path.dirname(dir);
+      if (parent === dir) return null;
+      dir = parent;
+    }
+  }
+
+  function ensurePeerDependencyAvailableForBuild(peerName: string): void {
+    const installedPkgJson = getInstalledPackageJsonPath(peerName);
+    if (fs.existsSync(installedPkgJson)) return;
+
+    const peerRange = packageJson.peerDependencies?.[peerName];
+    const localMap: Record<string, string> = {
+      '@openwebf/react-core-ui': path.join('packages', 'react-core-ui'),
+      '@openwebf/vue-core-ui': path.join('packages', 'vue-core-ui'),
+    };
+
+    let installSpec: string | null = null;
+
+    const localRel = localMap[peerName];
+    if (localRel) {
+      const localPath = findUp(process.cwd(), localRel);
+      if (localPath) {
+        if (!isPackageTypesReady(localPath)) {
+          const localPkgJsonPath = path.join(localPath, 'package.json');
+          if (fs.existsSync(localPkgJsonPath)) {
+            const localPkgJson = readJsonFile(localPkgJsonPath);
+            if (localPkgJson.scripts?.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 = spawnSync(NPM, ['run', 'build'], {
+                  cwd: localPath,
+                  stdio: 'inherit'
+                });
+                if (buildLocalResult.status === 0) {
+                  if (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 = 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 = getPackageTypesFileFromDir(getInstalledPackageDir(peerName));
+    if (installedTypesFile && !fs.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.join(packagePath, 'node_modules');
   if (!fs.existsSync(nodeModulesPath)) {
@@ -1204,6 +1298,14 @@ async function buildPackage(packagePath: string): Promise<void> {
 
   // Check if package has a build script
   if (packageJson.scripts?.build) {
+    // DTS build needs peer deps present locally to resolve types (even though they are not bundled).
+    if (packageJson.peerDependencies?.['@openwebf/react-core-ui']) {
+      ensurePeerDependencyAvailableForBuild('@openwebf/react-core-ui');
+    }
+    if (packageJson.peerDependencies?.['@openwebf/vue-core-ui']) {
+      ensurePeerDependencyAvailableForBuild('@openwebf/vue-core-ui');
+    }
+
     console.log(`\nBuilding ${packageName}@${packageVersion}...`);
     const buildResult = spawnSync(NPM, ['run', 'build'], {
       cwd: packagePath,
@@ -1300,4 +1402,4 @@ async function buildAndPublishPackage(packagePath: string, registry?: string, is
   }
 }
 
-export { generateCommand, generateModuleCommand };
+export { generateCommand, generateModuleCommand, agentsInitCommand };

package/src/generator.ts

@@ -407,13 +407,9 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
       warn(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
     }
   }
-  
-  timeEnd('reactGen');
-  success(`React code generation completed. ${filesChanged} files changed.`);
-  info(`Output directory: ${normalizedTarget}`);
-  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 ConstObject) as ConstObject[]);
     const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof EnumObject) as EnumObject[]);
@@ -426,40 +422,40 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
     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 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 typesContent = [
+      '/* Generated by WebF CLI - aggregated type declarations */',
+      hasAny ? typeAliasDecl : '',
+      hasAny ? constDecl : '',
+      hasAny ? enumDecl : '',
+      hasAny ? '' : 'export {};',
+      ''
+    ].filter(Boolean).join('\n');
 
-      const typesPath = path.join(normalizedTarget, 'src', 'types.ts');
-      if (writeFileIfChanged(typesPath, typesContent)) {
-        filesChanged++;
-        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);
-          debug(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
-          debug(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
-        } catch {}
-      }
+    const typesPath = path.join(normalizedTarget, 'src', 'types.ts');
+    if (writeFileIfChanged(typesPath, typesContent)) {
+      filesChanged++;
+      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);
+        debug(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+        debug(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
+      } catch {}
+    }
 
-      // Ensure index.ts re-exports these types so consumers get them on import.
-      const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
+    // Only re-export from index.ts when there are actual declarations to surface.
+    if (hasAny) {
       try {
         let current = '';
         if (fs.existsSync(indexFilePath)) {
@@ -478,6 +474,11 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   } catch (e) {
     warn('Failed to generate aggregated React types');
   }
+
+  timeEnd('reactGen');
+  success(`React code generation completed. ${filesChanged} files changed.`);
+  info(`Output directory: ${normalizedTarget}`);
+  info('You can now import these components in your React project.');
 }
 
 export async function vueGen({ source, target, exclude }: GenerateOptions) {

package/src/module.ts

@@ -335,14 +335,14 @@ function mapTsParamTypeToDart(
   return { dartType: 'dynamic', isByteData: false };
 }
 
-function mapTsPropertyTypeToDart(type: ts.TypeNode): string {
+function mapTsPropertyTypeToDart(type: ts.TypeNode, optional: boolean): string {
   switch (type.kind) {
     case ts.SyntaxKind.StringKeyword:
-      return 'String?';
+      return optional ? 'String?' : 'String';
     case ts.SyntaxKind.NumberKeyword:
-      return 'num?';
+      return optional ? 'num?' : 'num';
     case ts.SyntaxKind.BooleanKeyword:
-      return 'bool?';
+      return optional ? 'bool?' : 'bool';
     default:
       return 'dynamic';
   }
@@ -380,16 +380,17 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
 
   for (const iface of optionInterfaces) {
     const name = iface.name.text;
-    const propInfos: { fieldName: string; key: string; dartType: string }[] = [];
+    const propInfos: { fieldName: string; key: string; dartType: string; optional: boolean }[] = [];
 
     for (const member of iface.members) {
       if (!ts.isPropertySignature(member) || !member.name) continue;
 
       const key = member.name.getText(def.sourceFile).replace(/['"]/g, '');
       const fieldName = key;
-      const dartType = member.type ? mapTsPropertyTypeToDart(member.type) : 'dynamic';
+      const optional = !!member.questionToken;
+      const dartType = member.type ? mapTsPropertyTypeToDart(member.type, optional) : 'dynamic';
 
-      propInfos.push({ fieldName, key, dartType });
+      propInfos.push({ fieldName, key, dartType, optional });
     }
 
     lines.push(`class ${name} {`);
@@ -398,23 +399,50 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
     }
     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(),`);
-      } else if (prop.dartType.startsWith('bool')) {
-        lines.push(
-          `      ${prop.fieldName}: map['${prop.key}'] is bool ? map['${prop.key}'] as bool : null,`
-        );
-      } else if (prop.dartType.startsWith('num')) {
-        lines.push(
-          `      ${prop.fieldName}: map['${prop.key}'] is num ? map['${prop.key}'] as num : null,`
-        );
+      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 (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 (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}'],`);
       }
@@ -426,9 +454,13 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
     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('  }');

package/src/peerDeps.ts

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+
+export function readJsonFile(jsonPath: string): any {
+  return JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+}
+
+export function getPackageTypesFileFromDir(pkgDir: string): string | null {
+  const pkgJsonPath = path.join(pkgDir, 'package.json');
+  if (!fs.existsSync(pkgJsonPath)) return null;
+  const pkgJson = readJsonFile(pkgJsonPath);
+  const typesRel: string | undefined = pkgJson.types;
+  if (!typesRel) return null;
+  return path.join(pkgDir, typesRel);
+}
+
+export function isPackageTypesReady(pkgDir: string): boolean {
+  const typesFile = getPackageTypesFileFromDir(pkgDir);
+  return typesFile ? fs.existsSync(typesFile) : true;
+}
+