Refactor lexicon generation with improved error handling

tools/lexicon-cli/src/commands/generate.ts

···
-import { execa } from 'execa';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import pc from 'picocolors';
-import { findWorkspaceRoot } from '../utils/workspace.js';
+import { existsSync } from "fs";
+import { join } from "path";
+import { execa } from "execa";
+import pc from "picocolors";
+
+import { findWorkspaceRoot } from "../utils/workspace.js";
 
 interface GenerateOptions {
   tsOnly?: boolean;
···
 
 export async function generate(options: GenerateOptions = {}) {
   const workspaceRoot = findWorkspaceRoot();
-  
-  console.log(pc.blue('🔧 Generating lexicon types...'));
-  
+
+  console.log(pc.blue("🔧 Generating lexicon types..."));
+
   try {
     if (!options.rustOnly) {
       await generateTypeScript(workspaceRoot, options.force);
     }
-    
+
     if (!options.tsOnly) {
       await generateRust(workspaceRoot, options.force);
     }
-    
-    console.log(pc.green('✅ Lexicon generation complete!'));
+
+    console.log(pc.green("✅ Lexicon generation complete!"));
   } catch (error) {
-    console.error(pc.red('❌ Generation failed:'), error instanceof Error ? error.message : String(error));
+    console.error(
+      pc.red("❌ Generation failed:"),
+      error instanceof Error ? error.message : String(error),
+    );
     process.exit(1);
   }
 }
 
 async function generateTypeScript(workspaceRoot: string, force?: boolean) {
-  const lexiconsPath = join(workspaceRoot, 'lexicons');
-  
+  const lexiconsPath = join(workspaceRoot, "lexicons");
+
   if (!existsSync(lexiconsPath)) {
-    throw new Error('Lexicons directory not found at workspace root');
+    throw new Error("Lexicons directory not found at workspace root");
   }
-  
+
   // Check if packages/lexicons exists for TypeScript generation
-  const packagesLexiconsPath = join(workspaceRoot, 'packages/lexicons');
+  const packagesLexiconsPath = join(workspaceRoot, "packages/lexicons");
   if (!existsSync(packagesLexiconsPath)) {
-    console.log(pc.yellow('    ⚠️  TypeScript lexicons package not found, skipping TypeScript generation'));
+    console.log(
+      pc.yellow(
+        "    ⚠️  TypeScript lexicons package not found, skipping TypeScript generation",
+      ),
+    );
     return;
   }
-  
-  console.log(pc.cyan('  📦 Generating TypeScript types...'));
-  
+
+  console.log(pc.cyan("  📦 Generating TypeScript types..."));
+
   try {
-    await execa('pnpm', ['lex:gen-server'], {
+    await execa("pnpm", ["lex:gen-server"], {
       cwd: packagesLexiconsPath,
-      stdio: 'inherit'
+      stdio: "inherit",
     });
-    console.log(pc.green('    ✓ TypeScript types generated'));
+    console.log(pc.green("    ✓ TypeScript types generated"));
   } catch (error) {
-    throw new Error(`TypeScript generation failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(
+      `TypeScript generation failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
   }
 }
 
 async function generateRust(workspaceRoot: string, force?: boolean) {
-  const typesPath = join(workspaceRoot, 'services/types');
-  const lexiconsPath = join(workspaceRoot, 'lexicons');
-  
+  const typesPath = join(workspaceRoot, "services/types");
+  const lexiconsPath = join(workspaceRoot, "lexicons");
+
   if (!existsSync(typesPath)) {
-    throw new Error('Rust types service not found');
+    throw new Error("Rust types service not found");
   }
-  
+
   if (!existsSync(lexiconsPath)) {
-    throw new Error('Lexicons directory not found at workspace root');
+    throw new Error("Lexicons directory not found at workspace root");
   }
-  
-  console.log(pc.cyan('  🦀 Generating Rust types...'));
-  
+
+  console.log(pc.cyan("  🦀 Generating Rust types..."));
+
   try {
     // Check if esquema-cli is available
     try {
-      await execa('esquema-cli', ['--version'], { stdio: 'pipe' });
+      await execa("esquema-cli", ["--version"], { stdio: "pipe" });
     } catch {
-      console.log(pc.yellow('    ⚠️  esquema-cli not found. Installing...'));
+      console.log(pc.yellow("    ⚠️  esquema-cli not found. Installing..."));
       try {
-        await execa('cargo', [
-          'install',
-          'esquema-cli',
-          '--git',
-          'https://github.com/fatfingers23/esquema.git'
-        ], {
-          stdio: 'inherit'
-        });
-        console.log(pc.green('    ✓ esquema-cli installed successfully'));
+        await execa(
+          "cargo",
+          [
+            "install",
+            "esquema-cli",
+            "--git",
+            "https://github.com/fatfingers23/esquema.git",
+          ],
+          {
+            stdio: "inherit",
+          },
+        );
+        console.log(pc.green("    ✓ esquema-cli installed successfully"));
       } catch (installError) {
-        throw new Error('Failed to install esquema-cli. Please install manually: cargo install esquema-cli --git https://github.com/fatfingers23/esquema.git');
+        throw new Error(
+          "Failed to install esquema-cli. Please install manually: cargo install esquema-cli --git https://github.com/fatfingers23/esquema.git",
+        );
       }
     }
-    
-    await execa('esquema-cli', [
-      'generate',
-      'local',
-      '--lexdir',
-      lexiconsPath,
-      '--outdir',
-      join(typesPath, 'src')
-    ], {
-      cwd: typesPath,
-      stdio: 'inherit'
-    });
-    
-    console.log(pc.green('    ✓ Rust types generated'));
+
+    // create typespath/src if it doesn't exist
+    if (!existsSync(join(typesPath, "src"))) {
+      console.log(pc.yellow("    Creating src directory for Rust types..."));
+      await execa("mkdir", ["-p", join(typesPath, "src")], {
+        stdio: "inherit",
+      });
+    }
+
+    await execa(
+      "esquema-cli",
+      [
+        "generate",
+        "local",
+        "--lexdir",
+        lexiconsPath,
+        "--outdir",
+        join(typesPath, "src"),
+      ],
+      {
+        cwd: typesPath,
+        stdio: "inherit",
+      },
+    );
+
+    console.log(pc.green("    ✓ Rust types generated"));
   } catch (error) {
-    throw new Error(`Rust generation failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(
+      `Rust generation failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
   }
-}
+}