radtools 0.1.0

package/templates/api-routes/assets/route.ts

@@ -0,0 +1,159 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { readdir, stat, unlink, mkdir, writeFile } from 'fs/promises';
+import { join, relative, extname } from 'path';
+
+const ASSETS_DIR = join(process.cwd(), 'public', 'assets');
+
+interface AssetFile {
+  name: string;
+  path: string;
+  type: 'image' | 'video' | 'other';
+  size: number;
+}
+
+interface AssetFolder {
+  name: string;
+  path: string;
+  children: (AssetFolder | AssetFile)[];
+}
+
+// GET - List all assets
+export async function GET() {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    // Ensure assets directory exists
+    await mkdir(ASSETS_DIR, { recursive: true });
+    
+    // Also ensure subdirectories exist
+    const subdirs = ['icons', 'images', 'logos', 'backgrounds'];
+    for (const dir of subdirs) {
+      await mkdir(join(ASSETS_DIR, dir), { recursive: true });
+    }
+
+    const assets = await scanAssets(ASSETS_DIR);
+    return NextResponse.json({ assets });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to list assets', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+// POST - Upload asset
+export async function POST(req: NextRequest) {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const formData = await req.formData();
+    const file = formData.get('file') as File | null;
+    const folder = formData.get('folder') as string || '';
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    // Validate folder path to prevent directory traversal
+    const safePath = folder.replace(/\.\./g, '').replace(/^\/+/, '');
+    const targetDir = join(ASSETS_DIR, safePath);
+    
+    // Ensure target directory exists
+    await mkdir(targetDir, { recursive: true });
+
+    // Write file
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const filePath = join(targetDir, file.name);
+    await writeFile(filePath, buffer);
+
+    return NextResponse.json({ 
+      success: true, 
+      path: '/assets/' + safePath + '/' + file.name 
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to upload file', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE - Delete asset
+export async function DELETE(req: NextRequest) {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const { path: filePath } = await req.json();
+
+    // Validate path to prevent directory traversal
+    const safePath = filePath.replace(/\.\./g, '').replace(/^\/+/, '');
+    const fullPath = join(process.cwd(), 'public', safePath);
+
+    // Ensure the path is within the assets directory
+    if (!fullPath.startsWith(ASSETS_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+    }
+
+    await unlink(fullPath);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to delete file', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+async function scanAssets(dir: string): Promise<AssetFolder> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const children: (AssetFolder | AssetFile)[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relativePath = '/assets/' + relative(ASSETS_DIR, fullPath);
+
+    if (entry.isDirectory()) {
+      const folder = await scanAssets(fullPath);
+      children.push(folder);
+    } else {
+      const stats = await stat(fullPath);
+      const ext = extname(entry.name).toLowerCase();
+      
+      let type: 'image' | 'video' | 'other' = 'other';
+      if (['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.ico'].includes(ext)) {
+        type = 'image';
+      } else if (['.mp4', '.webm', '.mov', '.avi'].includes(ext)) {
+        type = 'video';
+      }
+
+      children.push({
+        name: entry.name,
+        path: relativePath,
+        type,
+        size: stats.size,
+      });
+    }
+  }
+
+  return {
+    name: dir === ASSETS_DIR ? 'assets' : relative(join(dir, '..'), dir),
+    path: '/assets/' + relative(ASSETS_DIR, dir),
+    children,
+  };
+}
+

package/templates/api-routes/components/create-folder/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+
+const COMPONENTS_DIR = join(process.cwd(), 'components');
+
+export async function POST(request: Request) {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const { folderName } = await request.json();
+
+    if (!folderName || typeof folderName !== 'string') {
+      return NextResponse.json(
+        { error: 'Folder name is required' },
+        { status: 400 }
+      );
+    }
+
+    // Validate folder name (alphanumeric, underscore, hyphen only)
+    if (!/^[a-zA-Z0-9_-]+$/.test(folderName)) {
+      return NextResponse.json(
+        { error: 'Folder name must contain only letters, numbers, underscores, or hyphens' },
+        { status: 400 }
+      );
+    }
+
+    const folderPath = join(COMPONENTS_DIR, folderName);
+
+    try {
+      await mkdir(folderPath, { recursive: false });
+      return NextResponse.json({ success: true, folderPath });
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code === 'EEXIST') {
+        return NextResponse.json(
+          { error: 'Folder already exists' },
+          { status: 409 }
+        );
+      }
+      throw error;
+    }
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to create folder', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+

package/templates/api-routes/components/route.ts

@@ -0,0 +1,156 @@
+import { NextResponse } from 'next/server';
+import { readdir, readFile } from 'fs/promises';
+import { join, relative } from 'path';
+
+const COMPONENTS_DIR = join(process.cwd(), 'components');
+
+interface DiscoveredComponent {
+  name: string;
+  path: string;
+  props: PropDefinition[];
+}
+
+interface PropDefinition {
+  name: string;
+  type: string;
+  required: boolean;
+  defaultValue?: string;
+}
+
+export async function GET(request: Request) {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const folder = searchParams.get('folder');
+
+    // If folder is specified, scan only that folder
+    const scanDir = folder
+      ? join(COMPONENTS_DIR, folder)
+      : COMPONENTS_DIR;
+
+    const components = await scanComponents(scanDir);
+    return NextResponse.json({ components });
+  } catch (error) {
+    // If components directory doesn't exist, return empty array
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return NextResponse.json({ components: [] });
+    }
+    return NextResponse.json(
+      { error: 'Failed to scan components', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+async function scanComponents(dir: string): Promise<DiscoveredComponent[]> {
+  const components: DiscoveredComponent[] = [];
+  
+  async function scan(currentDir: string) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.name.endsWith('.tsx') || entry.name.endsWith('.ts')) {
+        // Skip test files and stories
+        if (entry.name.includes('.test.') || entry.name.includes('.stories.')) {
+          continue;
+        }
+        
+        try {
+          const content = await readFile(fullPath, 'utf-8');
+          const component = parseComponent(content, '/' + relative(process.cwd(), fullPath));
+          if (component) {
+            components.push(component);
+          }
+        } catch (err) {
+          // Failed to parse component - skip
+        }
+      }
+    }
+  }
+  
+  await scan(dir);
+  return components;
+}
+
+function parseComponent(content: string, filePath: string): DiscoveredComponent | null {
+  // Check for default export
+  const hasDefaultExport = /export\s+default\s+function\s+(\w+)/.test(content) ||
+                           /export\s+default\s+(\w+)/.test(content);
+  
+  if (!hasDefaultExport) return null;
+
+  // Extract component name
+  const nameMatch = content.match(/export\s+default\s+function\s+(\w+)/);
+  const name = nameMatch?.[1] || 'Unknown';
+
+  // Extract props interface
+  const propsMatch = content.match(/interface\s+(\w+Props)\s*\{([^}]+)\}/);
+  const props: PropDefinition[] = [];
+  
+  if (propsMatch) {
+    const propsBody = propsMatch[2];
+    const propLines = propsBody.split('\n').filter((l) => l.trim());
+    
+    for (const line of propLines) {
+      const propMatch = line.match(/(\w+)(\?)?:\s*([^;]+)/);
+      if (propMatch) {
+        props.push({
+          name: propMatch[1],
+          type: propMatch[3].trim(),
+          required: !propMatch[2],
+        });
+      }
+    }
+  }
+
+  // Try inline type annotation if no interface found
+  if (props.length === 0) {
+    const inlineMatch = content.match(/\{\s*([^}]+)\s*\}\s*:\s*\{([^}]+)\}/);
+    if (inlineMatch) {
+      const propsBody = inlineMatch[2];
+      const propLines = propsBody.split(/[,;]/).filter((l) => l.trim());
+      
+      for (const line of propLines) {
+        const propMatch = line.trim().match(/(\w+)(\?)?:\s*(.+)/);
+        if (propMatch) {
+          props.push({
+            name: propMatch[1],
+            type: propMatch[3].trim(),
+            required: !propMatch[2],
+          });
+        }
+      }
+    }
+  }
+
+  // Extract default values from destructuring
+  const destructureMatch = content.match(/\{\s*([^}]+)\s*\}\s*:\s*(?:\w+Props|\{[^}]+\})/);
+  if (destructureMatch) {
+    const destructureBody = destructureMatch[1];
+    for (const prop of props) {
+      const defaultMatch = destructureBody.match(
+        new RegExp(`${prop.name}\\s*=\\s*(['"\`]?[^,}]+['"\`]?)`)
+      );
+      if (defaultMatch) {
+        prop.defaultValue = defaultMatch[1].trim();
+      }
+    }
+  }
+
+  return {
+    name,
+    path: filePath,
+    props,
+  };
+}
+

package/templates/api-routes/fonts/route.ts

@@ -0,0 +1,96 @@
+import { NextResponse } from 'next/server';
+import { readdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+const FONTS_DIR = join(process.cwd(), 'public', 'fonts');
+
+export async function GET() {
+  // Security: Block in production
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    // Check if fonts directory exists
+    if (!existsSync(FONTS_DIR)) {
+      return NextResponse.json({ fonts: [] });
+    }
+
+    // Read all files in fonts directory
+    const files = await readdir(FONTS_DIR);
+    
+    // Filter to only font files
+    const fontFiles = files.filter(file => {
+      const ext = file.split('.').pop()?.toLowerCase();
+      return ['woff2', 'woff', 'ttf', 'otf'].includes(ext || '');
+    });
+
+    // Group fonts by family name
+    const fontMap = new Map<string, Array<{ filename: string; path: string; format: string }>>();
+    
+    for (const file of fontFiles) {
+      // Extract font family name from filename
+      // Examples: "Mondwest-Regular.woff2" -> "Mondwest"
+      //           "Pixeloid-Sans-Bold.woff2" -> "Pixeloid Sans"
+      //           "joystix_monospace.ttf" -> "Joystix Monospace"
+      const nameWithoutExt = file.replace(/\.[^.]+$/, '');
+      
+      // Handle both dash and underscore separators
+      const parts = nameWithoutExt.split(/[-_]/);
+      
+      // Handle special cases:
+      // - "Pixeloid-Sans" or "Pixeloid-Mono" -> "Pixeloid Sans" / "Pixeloid Mono"
+      // - "joystix_monospace" -> "Joystix Monospace"
+      // - "Mondwest-Regular" -> "Mondwest"
+      let familyName = parts[0];
+      
+      if (parts.length > 1) {
+        const secondPart = parts[1];
+        // Check if second part is a type (Sans, Mono, Monospace) or a weight/style
+        if (secondPart === 'Sans' || secondPart === 'Mono') {
+          familyName = `${parts[0]} ${secondPart}`;
+        } else if (secondPart.toLowerCase() === 'monospace') {
+          familyName = `${parts[0]} Monospace`;
+        }
+        // Otherwise, it's likely a weight/style (Regular, Bold, etc.), so just use the first part
+      }
+      
+      // Capitalize first letter of each word
+      familyName = familyName
+        .split(' ')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+      
+      const ext = file.split('.').pop()?.toLowerCase() || '';
+      const path = `/fonts/${file}`;
+      
+      if (!fontMap.has(familyName)) {
+        fontMap.set(familyName, []);
+      }
+      
+      fontMap.get(familyName)!.push({
+        filename: file,
+        path,
+        format: ext,
+      });
+    }
+
+    // Convert to array format
+    const fonts = Array.from(fontMap.entries()).map(([family, files]) => ({
+      family,
+      files,
+    }));
+
+    return NextResponse.json({ fonts });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to list fonts', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+

package/templates/api-routes/fonts/upload/route.ts

@@ -0,0 +1,79 @@
+import { NextResponse } from 'next/server';
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+const FONTS_DIR = join(process.cwd(), 'public', 'fonts');
+
+export async function POST(req: Request) {
+  // Security: Block in production
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const formData = await req.formData();
+    const file = formData.get('file') as File;
+    const name = formData.get('name') as string;
+    const family = formData.get('family') as string;
+    const weight = formData.get('weight') as string;
+    const style = formData.get('style') as string;
+    const format = formData.get('format') as string;
+
+    if (!file) {
+      return NextResponse.json(
+        { error: 'No file provided' },
+        { status: 400 }
+      );
+    }
+
+    // Ensure fonts directory exists
+    if (!existsSync(FONTS_DIR)) {
+      await mkdir(FONTS_DIR, { recursive: true });
+    }
+
+    // Generate filename
+    const safeFamilyName = family.replace(/\s+/g, '-');
+    const weightLabel = getWeightLabel(parseInt(weight, 10));
+    const styleLabel = style === 'italic' ? '-Italic' : '';
+    const filename = `${safeFamilyName}-${weightLabel}${styleLabel}.${format}`;
+
+    // Write file
+    const filePath = join(FONTS_DIR, filename);
+    const buffer = Buffer.from(await file.arrayBuffer());
+    await writeFile(filePath, buffer);
+
+    // Return the public path
+    const publicPath = `/fonts/${filename}`;
+
+    return NextResponse.json({
+      success: true,
+      path: publicPath,
+      filename,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to upload font', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+function getWeightLabel(weight: number): string {
+  const labels: Record<number, string> = {
+    100: 'Thin',
+    200: 'ExtraLight',
+    300: 'Light',
+    400: 'Regular',
+    500: 'Medium',
+    600: 'SemiBold',
+    700: 'Bold',
+    800: 'ExtraBold',
+    900: 'Black',
+  };
+  return labels[weight] || 'Regular';
+}
+

package/templates/api-routes/read-css/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+const GLOBALS_PATH = join(process.cwd(), 'app', 'globals.css');
+
+export async function GET() {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json(
+      { error: 'Dev tools API not available in production' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const css = await readFile(GLOBALS_PATH, 'utf-8');
+    return new NextResponse(css, {
+      headers: {
+        'Content-Type': 'text/css',
+      },
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to read CSS', details: String(error) },
+      { status: 500 }
+    );
+  }
+}
+