codebakers 1.0.45 → 2.0.1

package/src/commands/generate.ts

@@ -0,0 +1,178 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+export async function generateCommand(type?: string): Promise<void> {
+  p.intro(chalk.bgCyan.black(' Generate '));
+
+  const generateType = type || await p.select({
+    message: 'What do you want to generate?',
+    options: [
+      { value: 'component', label: '🧩 Component' },
+      { value: 'page', label: '📄 Page' },
+      { value: 'api', label: '🔌 API Route' },
+      { value: 'hook', label: '🪝 Custom Hook' },
+      { value: 'store', label: '📦 Zustand Store' },
+      { value: 'form', label: '📝 Form Component' },
+    ],
+  });
+
+  if (p.isCancel(generateType)) return;
+
+  const name = await p.text({
+    message: 'Name:',
+    placeholder: generateType === 'page' ? 'dashboard' : 'MyComponent',
+    validate: (v) => !v ? 'Name is required' : undefined,
+  });
+
+  if (p.isCancel(name)) return;
+
+  const spinner = p.spinner();
+  spinner.start('Generating...');
+
+  await generateFile(generateType as string, name as string);
+  
+  spinner.stop(`Generated ${name}`);
+  p.outro('');
+}
+
+async function generateFile(type: string, name: string): Promise<void> {
+  const cwd = process.cwd();
+  
+  const templates: Record<string, { path: string; content: string }> = {
+    component: {
+      path: `src/components/${name}.tsx`,
+      content: `'use client';
+
+interface ${name}Props {
+  // props
+}
+
+export function ${name}({}: ${name}Props) {
+  return (
+    <div>
+      <h2>${name}</h2>
+    </div>
+  );
+}
+`,
+    },
+    page: {
+      path: `src/app/${name}/page.tsx`,
+      content: `export default function ${name.charAt(0).toUpperCase() + name.slice(1)}Page() {
+  return (
+    <div className="container mx-auto py-8">
+      <h1 className="text-2xl font-bold">${name}</h1>
+    </div>
+  );
+}
+`,
+    },
+    api: {
+      path: `src/app/api/${name}/route.ts`,
+      content: `import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  try {
+    return NextResponse.json({ data: [] });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 });
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    return NextResponse.json({ success: true }, { status: 201 });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 });
+  }
+}
+`,
+    },
+    hook: {
+      path: `src/hooks/use-${name.toLowerCase()}.ts`,
+      content: `import { useState, useEffect } from 'react';
+
+export function use${name}() {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  return { data, isLoading, error };
+}
+`,
+    },
+    store: {
+      path: `src/stores/${name.toLowerCase()}-store.ts`,
+      content: `import { create } from 'zustand';
+
+interface ${name}State {
+  items: unknown[];
+  isLoading: boolean;
+  setItems: (items: unknown[]) => void;
+  reset: () => void;
+}
+
+export const use${name}Store = create<${name}State>((set) => ({
+  items: [],
+  isLoading: false,
+  setItems: (items) => set({ items }),
+  reset: () => set({ items: [], isLoading: false }),
+}));
+`,
+    },
+    form: {
+      path: `src/components/forms/${name}-form.tsx`,
+      content: `'use client';
+
+import { useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { toast } from 'sonner';
+
+const schema = z.object({
+  name: z.string().min(1, 'Required'),
+});
+
+type FormData = z.infer<typeof schema>;
+
+export function ${name}Form({ onSuccess }: { onSuccess?: () => void }) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const form = useForm<FormData>({ resolver: zodResolver(schema) });
+
+  const onSubmit = async (data: FormData) => {
+    setIsSubmitting(true);
+    try {
+      // Submit
+      toast.success('Success!');
+      onSuccess?.();
+    } catch (error) {
+      toast.error('Failed');
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)}>
+      {/* Form fields */}
+      <button type="submit" disabled={isSubmitting}>
+        {isSubmitting ? 'Submitting...' : 'Submit'}
+      </button>
+    </form>
+  );
+}
+`,
+    },
+  };
+
+  const template = templates[type];
+  if (!template) throw new Error(`Unknown type: ${type}`);
+
+  const filePath = path.join(cwd, template.path);
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, template.content);
+}