pwa-sv 1.1.1

package/dist/process-fs-handler.js

@@ -0,0 +1,1199 @@
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import { existsSync } from 'fs';
+import path from 'path';
+import { Either } from 'effect';
+/**
+ * Creates a new SvelteKit project using pnpm create
+ * @param config Configuration object containing project details
+ */
+export const createSvelteProject = async (config) => {
+    console.log(`Creating SvelteKit project: ${config.projectName}`);
+    // Check if directory already exists
+    if (existsSync(config.projectName)) {
+        console.log(`Directory ${config.projectName} already exists. Removing...`);
+        fs.removeSync(config.projectName);
+    }
+    // Create the project using npx sv create followed by sv add for additional functionality
+    try {
+        // Create a basic SvelteKit project with TypeScript
+        await execa('npx', [
+            'sv',
+            'create',
+            config.projectName,
+            '--template',
+            'minimal',
+            '--types',
+            'ts',
+            '--install',
+            'pnpm',
+            '--no-add-ons' // Skip interactive add-ons prompt during creation for automation
+        ], {
+            stdio: 'inherit'
+        });
+        // Now add the necessary functionality using sv add with explicit package manager option
+        // Add ESLint for code quality
+        await execa('npx', [
+            'sv',
+            'add',
+            'eslint',
+            '--install',
+            'pnpm'
+        ], {
+            cwd: config.projectName, // Run in the project directory
+            stdio: 'inherit'
+        });
+        // Add Vitest for testing (automatically select both unit and component testing)
+        const vitestResult = await execa('npx', [
+            'sv',
+            'add',
+            'vitest',
+            '--install',
+            'pnpm'
+        ], {
+            cwd: config.projectName, // Run in the project directory
+            input: '\n\n' // Provide answers to interactive prompts (press Enter for defaults)
+        });
+        // Add Playwright for end-to-end testing (only if requested)
+        if (config.usePlaywright) {
+            await execa('npx', [
+                'sv',
+                'add',
+                'playwright',
+                '--install',
+                'pnpm'
+            ], {
+                cwd: config.projectName, // Run in the project directory
+                stdio: 'inherit'
+            });
+        }
+        console.log(`SvelteKit project ${config.projectName} created successfully`);
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create SvelteKit project:', error);
+        return Either.left(new Error(`Failed to create SvelteKit project: ${error.message}`));
+    }
+};
+/**
+ * Handles file system operations for the project
+ * @param projectName Name of the project
+ * @param content Content to write to a file
+ * @param filePath Path of the file to write
+ */
+export const writeFile = async (projectName, content, filePath) => {
+    try {
+        const fullPath = path.join(projectName, filePath);
+        await fs.outputFile(fullPath, content);
+        console.log(`File written: ${fullPath}`);
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error(`Failed to write file ${filePath}:`, error);
+        return Either.left(new Error(`Failed to write file: ${error.message}`));
+    }
+};
+/**
+ * Reads a file from the project
+ * @param projectName Name of the project
+ * @param filePath Path of the file to read
+ * @returns Content of the file
+ */
+export const readFile = async (projectName, filePath) => {
+    try {
+        const fullPath = path.join(projectName, filePath);
+        const content = await fs.readFile(fullPath, 'utf8');
+        return Either.right(content);
+    }
+    catch (error) {
+        console.error(`Failed to read file ${filePath}:`, error);
+        return Either.left(new Error(`Failed to read file: ${error.message}`));
+    }
+};
+/**
+ * Creates PWA configuration file (vite.config.ts) for the SvelteKit project
+ * @param projectName Name of the project
+ */
+export const createPWAConfig = async (projectName) => {
+    console.log(`Creating PWA configuration file for project: ${projectName}`);
+    // Define content for vite.config.ts with PWA plugin configuration
+    const viteConfigContent = `import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+// Read package.json to get app metadata
+const file = fileURLToPath(import.meta.url);
+const currentDir = dirname(file);
+const packageJsonPath = resolve(currentDir, 'package.json');
+let appInfo = { name: 'My SvelteKit PWA', shortName: 'SveltePWA', description: 'A SvelteKit Progressive Web App' };
+
+try {
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+  const packageJson = JSON.parse(packageJsonContent);
+  appInfo = {
+    name: packageJson.name || 'My SvelteKit PWA',
+    shortName: packageJson.shortName || packageJson.name || 'SveltePWA',
+    description: packageJson.description || 'A SvelteKit Progressive Web App'
+  };
+} catch (error) {
+  console.warn('Could not read package.json, using default app info');
+}
+
+// Define icons configuration for different device sizes
+const iconsConfig = {
+  src: 'src/lib/assets/pwa-icon.png', // Default PWA icon path
+  sizes: [64, 192, 512],
+  destination: 'static/',
+  injection: true
+};
+
+// Vite configuration with PWA plugin
+export default defineConfig({
+  plugins: [
+    sveltekit(),
+    // PWA Configuration
+    process.env.NODE_ENV === 'production' 
+      ? ((): any => {
+          const { VitePWA } = require('vite-plugin-pwa');
+          return VitePWA({
+            strategies: 'injectManifest', // Use injectManifest strategy for more control
+            srcDir: 'src',
+            filename: 'sw.ts', // Service worker file
+            injectRegister: 'auto', // Auto register service worker
+            workbox: {
+              globPatterns: ['**/*.{js,css,html,ico,png,svg,woff2}'], // Files to cache
+              runtimeCaching: [
+                // Cache API calls with network-first strategy
+                {
+                  urlPattern: /^https:\\/\\/.*/i,
+                  handler: 'NetworkFirst',
+                  options: {
+                    cacheName: 'api-cache',
+                    expiration: {
+                      maxEntries: 20,
+                      maxAgeSeconds: 30 * 24 * 60 * 60, // 30 days
+                    },
+                  },
+                },
+                // Cache static assets with cache-first strategy
+                {
+                  urlPattern: /^https:\\/\\/(?:fonts|images)\\.*/i,
+                  handler: 'CacheFirst',
+                  options: {
+                    cacheName: 'static-assets-cache',
+                    expiration: {
+                      maxEntries: 100,
+                      maxAgeSeconds: 30 * 24 * 60 * 60, // 30 days
+                    },
+                  },
+                }
+              ]
+            },
+            manifest: {
+              name: appInfo.name,
+              short_name: appInfo.shortName,
+              description: appInfo.description,
+              theme_color: '#42b549',
+              background_color: '#ffffff',
+              display: 'standalone',
+              orientation: 'portrait',
+              scope: '/',
+              start_url: '/',
+              icons: [
+                {
+                  src: 'pwa-64x64.png',
+                  sizes: '64x64',
+                  type: 'image/png'
+                },
+                {
+                  src: 'pwa-192x192.png',
+                  sizes: '192x192',
+                  type: 'image/png'
+                },
+                {
+                  src: 'pwa-512x512.png',
+                  sizes: '512x512',
+                  type: 'image/png'
+                },
+                {
+                  src: 'maskable-icon-512x512.png',
+                  sizes: '512x512',
+                  type: 'image/png',
+                  purpose: 'maskable'
+                }
+              ]
+            }
+          });
+        })()
+      : null // Only include PWA plugin in production builds
+  ].filter(Boolean), // Filter out null plugins
+
+  // Additional configuration for PWA
+  build: {
+    sourcemap: true // Generate sourcemaps
+  }
+});
+`;
+    try {
+        // Write vite.config.ts file
+        const configResult = await writeFile(projectName, viteConfigContent, 'vite.config.ts');
+        if (Either.isLeft(configResult)) {
+            return configResult;
+        }
+        console.log('PWA configuration file created successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create PWA configuration file:', error);
+        return Either.left(new Error(`Failed to create PWA configuration file: ${error.message}`));
+    }
+};
+/**
+ * Updates package.json with PWA-specific scripts
+ * @param projectName Name of the project
+ */
+export const updatePackageJsonWithPWAScripts = async (projectName) => {
+    console.log(`Updating package.json with PWA scripts for project: ${projectName}`);
+    try {
+        const packageJsonPath = path.join(projectName, 'package.json');
+        // Read the existing package.json file
+        if (!await fs.pathExists(packageJsonPath)) {
+            return Either.left(new Error('package.json file not found'));
+        }
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(packageJsonContent);
+        // Define PWA-specific scripts to add (only unique ones, avoiding duplicates of standard scripts)
+        const pwaScripts = {
+            'build-pwa-assets': 'pwa-asset-generator' // Uses pwa-assets.config.ts for Android and web assets only
+        };
+        // Merge the new scripts with existing scripts
+        packageJson.scripts = {
+            ...packageJson.scripts, // Keep existing scripts
+            ...pwaScripts // Add PWA scripts
+        };
+        // Add pwa-asset-generator to devDependencies if it doesn't exist yet
+        if (!packageJson.devDependencies) {
+            packageJson.devDependencies = {};
+        }
+        if (!packageJson.devDependencies['pwa-asset-generator']) {
+            packageJson.devDependencies['pwa-asset-generator'] = '^6.0.0';
+        }
+        // Write the updated package.json back to the file
+        await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log('PWA scripts added to package.json successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to update package.json with PWA scripts:', error);
+        return Either.left(new Error(`Failed to update package.json with PWA scripts: ${error.message}`));
+    }
+};
+/**
+ * Creates pwa-asset-generator configuration file to generate assets for Android and web only (excluding iOS)
+ * @param projectName Name of the project
+ */
+export const createPWAAssetConfig = async (projectName) => {
+    console.log(`Creating pwa-asset-generator configuration for project: ${projectName}`);
+    const pwaAssetsConfigContent = `import { defineConfig } from '@vite-pwa/assets-generator/config'
+
+export default defineConfig({
+  headLinkOptions: { preset: '2023' },
+  preset: {
+    transparent: {
+      sizes: [64, 192, 512],
+      favicons: [[48, 'favicon.ico']]
+    },
+    maskable: {
+      sizes: [512]
+    }
+    // NOTE: Apple property is intentionally omitted to exclude iOS assets
+  },
+  images: ['src/lib/assets/pwa-icon.png']
+})
+`;
+    try {
+        // Write pwa-assets.config.ts file
+        const configResult = await writeFile(projectName, pwaAssetsConfigContent, 'pwa-assets.config.ts');
+        if (Either.isLeft(configResult)) {
+            return configResult;
+        }
+        console.log('pwa-asset-generator configuration file created successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create pwa-asset-generator configuration file:', error);
+        return Either.left(new Error(`Failed to create pwa-asset-generator configuration file: ${error.message}`));
+    }
+};
+/**
+ * Validates the project structure to ensure it matches expected architecture
+ * @param projectName Name of the project to validate
+ */
+export const validateProjectStructure = async (projectName) => {
+    console.log(`Validating project structure for: ${projectName}`);
+    try {
+        // Define the expected files and directories that should exist in a properly created PWA project
+        const expectedFiles = [
+            'package.json',
+            'README.md',
+            'vite.config.ts', // Added by createPWAConfig
+            'svelte.config.js',
+            '.gitignore',
+            'static/', // Static assets directory
+            'src/',
+            'src/app.html',
+            'src/routes/',
+            'src/lib/',
+            'tsconfig.json'
+        ];
+        // Check for the existence of each expected file/directory
+        for (const expectedFile of expectedFiles) {
+            const fullPath = path.join(projectName, expectedFile);
+            const exists = await fs.pathExists(fullPath);
+            if (!exists) {
+                console.error(`Project structure validation failed: Missing expected file/directory: ${expectedFile}`);
+                return Either.left(new Error(`Project structure validation failed: Missing expected file/directory: ${expectedFile}`));
+            }
+        }
+        console.log('Project structure validation passed successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Project structure validation failed with error:', error);
+        return Either.left(new Error(`Project structure validation failed: ${error.message}`));
+    }
+};
+/**
+ * Creates Skeleton UI configuration files and setup
+ * @param projectName Name of the project to configure
+ */
+export const createSkeletonUIConfig = async (projectName) => {
+    console.log(`Creating Skeleton UI configuration for: ${projectName}`);
+    try {
+        // Create Tailwind CSS configuration file
+        const tailwindConfigContent = `import { Config } from 'tailwindcss';
+import { skeleton } from '@skeletonlabs/skeleton/tailwind/skeleton.cjs';
+
+export default {
+  content: [
+    './src/**/*.{html,js,svelte,ts}',
+    './node_modules/@skeletonlabs/skeleton/**/*.{html,js,svelte,ts}'
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [
+    skeleton({
+      themes: {
+        preset: [
+          {
+            name: 'skeleton',
+            enhancements: true,
+          }
+        ]
+      }
+    })
+  ]
+} satisfies Config;
+`;
+        // Write tailwind.config.cjs file
+        const tailwindResult = await writeFile(projectName, tailwindConfigContent, 'tailwind.config.cjs');
+        if (Either.isLeft(tailwindResult)) {
+            return tailwindResult;
+        }
+        // Create svelte.config.js with Skeleton UI integration (if not exists or update existing)
+        const svelteConfigPath = path.join(projectName, 'svelte.config.js');
+        let svelteConfigContent = `import { vitePreprocess } from '@sveltejs/kit/vite';
+import adapter from '@sveltejs/adapter-auto';
+import { resolve } from 'path';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+  preprocess: [vitePreprocess({})],
+  kit: {
+    adapter: adapter(),
+    alias: {
+      $lib: 'src/lib',
+      $components: 'src/lib/components' // Common alias for components
+    }
+  }
+};
+
+export default config;
+`;
+        // Write svelte.config.js file
+        const svelteConfigResult = await writeFile(projectName, svelteConfigContent, 'svelte.config.js');
+        if (Either.isLeft(svelteConfigResult)) {
+            return svelteConfigResult;
+        }
+        // Create app.html with Tailwind CSS integration
+        const appHtmlPath = path.join(projectName, 'src', 'app.html');
+        if (await fs.pathExists(appHtmlPath)) {
+            // Read existing app.html and add Tailwind CSS classes to body tag
+            const existingAppHtml = await fs.readFile(appHtmlPath, 'utf8');
+            let updatedAppHtml = existingAppHtml;
+            if (existingAppHtml.includes('<body')) {
+                // Replace the body tag with Tailwind classes
+                updatedAppHtml = existingAppHtml.replace(/<body([^>]*)>/i, '<body$1 class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100">');
+            }
+            else {
+                // If body tag doesn't exist, add it with Tailwind classes and data-theme for skeleton
+                updatedAppHtml = `<!DOCTYPE html>
+<html lang="en" data-theme="cerberus">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.png" />
+    <meta name="viewport" content="width=device-width" />
+    %sveltekit.head%
+  </head>
+  <body class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100">
+    %sveltekit.body%
+  </body>
+</html>`;
+            }
+            // Add data-theme to html tag if not present for skeleton
+            if (existingAppHtml.includes('<html') && !existingAppHtml.match(/<html[^>]*data-theme\b/i)) {
+                updatedAppHtml = updatedAppHtml.replace(/<html([^>]*)>/i, '<html$1 data-theme="cerberus">');
+            }
+            await fs.writeFile(appHtmlPath, updatedAppHtml);
+        }
+        // Create base CSS file with Tailwind and Skeleton imports
+        const cssContent = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@import '@skeletonlabs/skeleton';
+@import '@skeletonlabs/skeleton-svelte';
+@import '@skeletonlabs/skeleton/themes/cerberus.css';
+
+/* Your custom styles go here */
+`;
+        const cssResult = await writeFile(projectName, cssContent, 'src/app.postcss');
+        if (Either.isLeft(cssResult)) {
+            return cssResult;
+        }
+        // Create a sample component that demonstrates Skeleton UI usage
+        const sampleComponentContent = `<script>
+  import { Button } from '@skeletonlabs/skeleton';
+  import { Popup } from '@skeletonlabs/skeleton';
+  import { Modal } from '@skeletonlabs/skeleton';
+</script>
+
+<div>
+  <h1 class="text-2xl font-bold mb-4">Welcome to Skeleton UI!</h1>
+  <Button variant="primary">Click me</Button>
+  <p class="mt-4">This project includes Skeleton UI components.</p>
+</div>
+`;
+        // Write sample component file
+        const componentResult = await writeFile(projectName, sampleComponentContent, 'src/lib/components/SkeletonExample.svelte');
+        if (Either.isLeft(componentResult)) {
+            return componentResult;
+        }
+        console.log('Skeleton UI configuration created successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create Skeleton UI configuration:', error);
+        return Either.left(new Error(`Failed to create Skeleton UI configuration: ${error.message}`));
+    }
+};
+/**
+ * Creates internationalization (i18n) configuration files and setup
+ * @param projectName Name of the project to configure
+ */
+export const createI18nConfig = async (projectName) => {
+    console.log(`Creating internationalization configuration for: ${projectName}`);
+    try {
+        // Create i18n configuration file
+        const i18nConfigContent = `import { browser, locales, negotiate } from '$app/env';
+import { init, register } from 'svelte-i18n';
+
+// Initialize internationalization
+export const setupI18n = () => {
+  // Register the locales directory
+  register('en', () => import('./locales/en.json'));
+  register('es', () => import('./locales/es.json'));
+  register('de', () => import('./locales/de.json'));
+  register('fr', () => import('./locales/fr.json'));
+
+  // Initialize the i18n system
+  init({
+    fallbackLocale: 'en',
+    initialLocale: browser ? undefined : 'en',
+    warnOnMissing: true
+  });
+};
+
+// Export common i18n functions
+export { default as t } from 'svelte-i18n';
+`;
+        // Write i18n configuration file
+        const i18nConfigResult = await writeFile(projectName, i18nConfigContent, 'src/lib/i18n/config.js');
+        if (Either.isLeft(i18nConfigResult)) {
+            return i18nConfigResult;
+        }
+        // Create directory for locale files if it doesn't exist
+        const localesDirPath = path.join(projectName, 'src', 'lib', 'locales');
+        await fs.ensureDir(localesDirPath);
+        // Create default English locale file
+        const enLocaleContent = `{
+  "welcome": "Welcome",
+  "hello": "Hello",
+  "goodbye": "Goodbye",
+  "app_title": "My PWA App",
+  "nav_home": "Home",
+  "nav_about": "About",
+  "nav_contact": "Contact",
+  "button_submit": "Submit",
+  "button_cancel": "Cancel",
+  "error_required": "This field is required",
+  "error_invalid": "Invalid input",
+  "success_message": "Operation completed successfully"
+}`;
+        // Write English locale file
+        const enLocaleResult = await writeFile(projectName, enLocaleContent, 'src/lib/locales/en.json');
+        if (Either.isLeft(enLocaleResult)) {
+            return enLocaleResult;
+        }
+        // Create sample Spanish locale file
+        const esLocaleContent = `{
+  "welcome": "Bienvenido",
+  "hello": "Hola",
+  "goodbye": "Adios",
+  "app_title": "Mi aplicacion PWA",
+  "nav_home": "Inicio",
+  "nav_about": "Acerca de",
+  "nav_contact": "Contacto",
+  "button_submit": "Enviar",
+  "button_cancel": "Cancelar",
+  "error_required": "Este campo es obligatorio",
+  "error_invalid": "Entrada invalida",
+  "success_message": "Operacion completada exitosamente"
+}`;
+        // Write Spanish locale file
+        const esLocaleResult = await writeFile(projectName, esLocaleContent, 'src/lib/locales/es.json');
+        if (Either.isLeft(esLocaleResult)) {
+            return esLocaleResult;
+        }
+        // Create a sample i18n-enabled component
+        const sampleI18nComponentContent = `<script>
+  import { t } from '$lib/i18n/config.js';
+  import { onMount } from 'svelte';
+  import { locale } from 'svelte-i18n';
+
+  // Set default language
+  onMount(async () => {
+    locale.set('en');
+  });
+</script>
+
+<div>
+  <h1>{t('app_title')}</h1>
+  <p>{t('welcome')}</p>
+  <button on:click={() => locale.set('es')}>Spanish</button>
+  <button on:click={() => locale.set('en')}>English</button>
+</div>
+`;
+        // Write sample component file
+        const componentResult = await writeFile(projectName, sampleI18nComponentContent, 'src/lib/components/I18nExample.svelte');
+        if (Either.isLeft(componentResult)) {
+            return componentResult;
+        }
+        // Update app.html to include locale attribute
+        const appHtmlPath = path.join(projectName, 'src', 'app.html');
+        if (await fs.pathExists(appHtmlPath)) {
+            const existingAppHtml = await fs.readFile(appHtmlPath, 'utf8');
+            let updatedAppHtml = existingAppHtml;
+            // Add lang attribute to html tag if not present
+            if (existingAppHtml.includes('<html')) {
+                // Check if lang attribute already exists to avoid duplicates
+                if (!existingAppHtml.match(/<html[^>]*lang\b/i)) {
+                    updatedAppHtml = existingAppHtml.replace(/<html([^>]*)>/i, '<html$1 lang="en"');
+                }
+            }
+            else {
+                // If html tag doesn't exist, add proper structure with lang attribute
+                updatedAppHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.png" />
+    <meta name="viewport" content="width=device-width" />
+    %sveltekit.head%
+  </head>
+  <body>
+    %sveltekit.body%
+  </body>
+</html>`;
+            }
+            await fs.writeFile(appHtmlPath, updatedAppHtml);
+        }
+        // Update package.json to add i18n scripts if they don't exist
+        const packageJsonPath = path.join(projectName, 'package.json');
+        if (await fs.pathExists(packageJsonPath)) {
+            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+            let packageJson;
+            try {
+                packageJson = JSON.parse(packageJsonContent);
+            }
+            catch (e) {
+                // If package.json is invalid, skip updating it
+                console.warn('Could not parse package.json, skipping i18n scripts update');
+            }
+            if (packageJson && packageJson.scripts) {
+                // Add i18n-related scripts
+                packageJson.scripts = {
+                    ...packageJson.scripts,
+                    'i18n:extract': 'i18n-extract report src/**/*.svelte src/**/*.js src/**/*.ts',
+                    'i18n:check': 'i18n-extract report --fail-on-translation-keys-missing-from-source src/**/*.svelte src/**/*.js src/**/*.ts'
+                };
+                await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+            }
+        }
+        console.log('Internationalization configuration created successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create internationalization configuration:', error);
+        return Either.left(new Error(`Failed to create internationalization configuration: ${error.message}`));
+    }
+};
+/**
+ * Creates AGENTS.md file with functional programming guidelines and empty docs folder
+ * @param projectName Name of the project
+ */
+export const createAgentsFileAndDocsFolder = async (projectName) => {
+    console.log(`Creating AGENTS.md file and docs folder for project: ${projectName}`);
+    // Define content for AGENTS.md with functional programming guidelines
+    const agentsContent = `# Functional Programming Guidelines for AI Agents
+
+This document provides explicit instructions for AI agents to follow functional programming paradigms when generating or modifying code. Adhere strictly to these principles.
+
+## Core Functional Programming Principles
+
+### Immutability & Pure Functions
+- **Prefer immutability** - Use immutable data patterns wherever possible
+- **Pure functions** - Functions should not produce side effects and should return the same output for same inputs
+- **Immutable data operations** - Use non-mutating methods for objects and arrays
+
+### Error Handling with Effect Types
+- **NO exceptions** - Use \`Effect<T, E>\` types from \`effect\` library instead of throwing errors
+- **Explicit error handling** - All possible errors must be represented in return types
+- **Predictable control flow** - Use \`map\`, \`flatMap\`, \`match\` for error handling chains
+
+### TypeScript-First Development
+- **Proper TypeScript syntax only** - NO JSDoc type annotations allowed
+- **Explicit type annotations** - All functions, parameters, and returns must have TypeScript types
+- **Generic types** - Use TypeScript generics for reusable, type-safe code
+
+## Implementation Rules
+
+### Function Design
+\`\`\`typescript
+// ✅ CORRECT - Pure function with Effect type
+import { Effect, pipe } from "effect";
+
+const processUser = (user: User): Effect.Effect<ProcessedUser, ValidationError> => {
+  return pipe(
+    Effect.succeed(user),
+    Effect.andThen(validateUser),
+    Effect.map(transformUser),
+    Effect.map(enrichUserData)
+  );
+}
+
+// ❌ INCORRECT - Throws exceptions, mutable parameters
+function processUser(user: User): ProcessedUser {
+  if (!user.valid) throw new Error("Invalid user");
+  user.processed = true; // Mutation!
+  return user;
+}
+\`\`\`
+
+### State Management in Svelte Components
+\`\`\`typescript
+// ✅ CORRECT - Svelte reactive declarations with proper typing
+<script lang="ts">
+  // Svelte component state - let is required for reactivity
+  let count = $state<number>(0);
+  let users = $state<ReadonlyArray<User>>([]);
+
+  // Immutable updates to Svelte state
+  const addUser = (newUser: User): void => {
+    users = [...users, newUser]; // ✅ Correct - immutable update
+  };
+
+  const updateUser = (id: string, updates: Partial<User>): void => {
+    users = users.map(user =>
+      user.id === id ? { ...user, ...updates } : user
+    );
+  };
+</script>
+
+// ❌ INCORRECT - Direct mutation of Svelte state
+<script lang="ts">
+  let users = $state<User[]>([]);
+
+  const addUser = (newUser: User): void => {
+    users.push(newUser); // ❌ Mutation - avoid this pattern
+  };
+</script>
+\`\`\`
+
+### Pure TypeScript Modules (Non-Svelte)
+\`\`\`typescript
+// ✅ CORRECT - Pure functional module with const
+import { Effect } from "effect";
+
+export const processUsers = (users: ReadonlyArray<User>): Effect.Effect<ReadonlyArray<ProcessedUser>, Error> => {
+  return Effect.gen(function*() {
+    const validUsers = yield* Effect.succeed(users.filter(isValidUser));
+    return yield* Effect.forEach(validUsers, processUser);
+  });
+};
+
+// ❌ INCORRECT - Mutable variables in pure TypeScript
+export let processedUsers: User[] = []; // ❌ Avoid module-level mutable variables
+
+export function addUser(user: User): void {
+  processedUsers.push(user); // ❌ Mutation
+}
+\`\`\`
+
+### Error Handling Patterns
+\`\`\`typescript
+// ✅ CORRECT - Using effect
+import { Effect, pipe } from "effect";
+
+const fetchUser = (id: string): Effect.Effect<User, NetworkError | NotFoundError> => {
+  return pipe(
+    Effect.try({
+      try: () => apiCall(id),
+      catch: (error) => error as NetworkError
+    }),
+    Effect.andThen(validateResponse),
+    Effect.map(parseUserData)
+  );
+}
+
+// Usage with proper handling
+const result = pipe(
+  fetchUser('123'),
+  Effect.match({
+    onFailure: (error) => { /* handle error */ },
+    onSuccess: (user) => { /* handle success */ }
+  })
+);
+\`\`\`
+
+## Svelte 5 Specific Guidelines
+
+### State Management
+- Use \`let\` with \`\\$state<T>()\` for Svelte component reactive state
+- Use immutable patterns when updating Svelte state (spread operator, map, filter)
+- Prefer \`readonly\` types for state that shouldn't be mutated externally
+- Use \`\\$effect()\` for side effects with proper TypeScript typing
+
+### Component Patterns
+\`\`\`typescript
+// ✅ CORRECT - Functional Svelte component with immutable patterns
+<script lang="ts">
+  // Svelte state declarations use let + $state
+  let count = $state<number>(0);
+  let items = $state<ReadonlyArray<string>>([]);
+
+  // Pure functions for business logic
+  const increment = (): void => {
+    count += 1; // ✅ This is Svelte reactivity, not variable reassignment
+  };
+
+  const addItem = (item: string): void => {
+    items = [...items, item]; // ✅ Immutable update
+  };
+
+  const removeItem = (index: number): void => {
+    items = items.filter((_, i) => i !== index); // ✅ Immutable update
+  };
+
+  $effect(() => {
+    // Side effects here
+    console.log(\`Count is: \${count}\`);
+  });
+</script>
+\`\`\`
+
+## Mandatory Checks Before Code Generation
+
+1. **Immutability Check**: No direct mutation of objects/arrays (use spread, map, filter instead)
+2. **Error Handling Check**: All possible errors must return Effect types, no throw statements
+3. **TypeScript Check**: Proper TypeScript syntax, no JSDoc types, explicit return types
+4. **Purity Check**: No side effects in pure functions, all dependencies explicit
+5. **Svelte Context Check**: Use \`let\` only in Svelte components for reactive state, use \`const\` elsewhere
+
+## Prohibited Patterns
+
+- ❌ \`throw new Error()\` (use Effect types instead)
+- ❌ Direct mutation: \`array.push()\`, \`array.splice()\`, \`object.property = value\`
+- ❌ JSDoc \`@type\`, \`@param\`, \`@return\` annotations (use TypeScript syntax)
+- ❌ \`let\` in pure TypeScript modules (use \`const\`)
+- ❌ Class inheritance (\`extends\`) - prefer composition
+
+## Required Patterns
+
+- ✅ \`let\` + \`\\$state<T>()\` for Svelte component reactive state
+- ✅ \`const\` for all variable declarations outside Svelte components
+- ✅ \`Effect<T, E>\` from effect for error handling
+- ✅ \`map\`, \`filter\`, \`reduce\` for iteration with immutable updates
+- ✅ TypeScript interface/type definitions
+- ✅ Pure functions with explicit return types
+- ✅ Immutable updates to Svelte state: \`array = [...array, newItem]\`
+
+## Context-Specific Rules
+
+### In Svelte Components (.svelte files):
+\`\`\`typescript
+// ✅ REQUIRED - Use let for reactive state
+let count = $state<number>(0);
+let user = $state<User | null>(null);
+
+// ✅ Use const for helper functions
+const calculateTotal = (items: readonly Item[]): number => {
+  return items.reduce((sum, item) => sum + item.price, 0);
+};
+\`\`\`
+
+### In TypeScript Modules (.ts files):
+\`\`\`typescript
+// ✅ REQUIRED - Use const for all declarations
+import { Effect } from "effect";
+
+export const DEFAULT_CONFIG = { theme: 'dark' } as const;
+export const processData = (data: Data): Effect.Effect<Output, Error> => {
+  // Pure functional logic using Effect
+  return Effect.succeed(data);
+};
+\`\`\`
+
+**Remember**: Functional programming principles are maintained through immutable data operations and pure functions, while respecting Svelte's reactive declaration patterns that require \`let\` for component state.
+`;
+    try {
+        // Create the docs directory
+        const docsPath = path.join(projectName, 'docs');
+        await fs.ensureDir(docsPath);
+        console.log('Created empty docs folder');
+        // Write the AGENTS.md file
+        const agentsResult = await writeFile(projectName, agentsContent, 'AGENTS.md');
+        if (Either.isLeft(agentsResult)) {
+            return agentsResult;
+        }
+        // Create empty PRD.md file
+        const prdContent = `# Product Requirements Document (PRD)
+
+## Project Overview
+- **Project Name**: 
+- **Purpose**: 
+- **Target Audience**: 
+- **Key Features**: 
+
+## Requirements
+### Functional Requirements
+- 
+
+### Non-Functional Requirements
+- 
+
+## Success Metrics
+- 
+
+## Timeline
+- **Start Date**: 
+- **Target Completion**: 
+
+## Resources Needed
+- 
+`;
+        const prdResult = await writeFile(projectName, prdContent, 'docs/PRD.md');
+        if (Either.isLeft(prdResult)) {
+            return prdResult;
+        }
+        // Create empty Architecture.md file
+        const archContent = `# System Architecture
+
+## Overview
+- **Architecture Type**: 
+- **Main Components**: 
+
+## Components
+### Frontend
+- 
+
+### Backend
+- 
+
+### Database
+- 
+
+### External Services
+- 
+
+## Data Flow
+- 
+
+## Deployment Architecture
+- 
+
+## Security Considerations
+- 
+`;
+        const archResult = await writeFile(projectName, archContent, 'docs/Architecture.md');
+        if (Either.isLeft(archResult)) {
+            return archResult;
+        }
+        console.log('AGENTS.md file created successfully');
+        console.log('PRD.md file created successfully');
+        console.log('Architecture.md file created successfully');
+        // Create .gitignore file
+        const gitignoreResult = await createGitignore(projectName);
+        if (Either.isLeft(gitignoreResult)) {
+            return gitignoreResult;
+        }
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create AGENTS.md file and docs folder:', error);
+        return Either.left(new Error(`Failed to create AGENTS.md file and docs folder: ${error.message}`));
+    }
+};
+/**
+ * Creates a .gitignore file for the SvelteKit project
+ * @param projectName Name of the project
+ */
+export const createGitignore = async (projectName) => {
+    console.log(`Creating .gitignore file for project: ${projectName}`);
+    // Define content for .gitignore file
+    const gitignoreContent = `# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out/
+
+# Nuxt build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Ds Store
+.DS_Store
+
+# Mac files
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows thumbnail cache
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Windows shortcut files
+*.lnk
+
+# SvelteKit
+.output
+build/
+
+# Production
+dist/
+
+# Static files (PWA assets and other static assets)
+static/
+
+# .env
+.env
+
+# Coverage
+coverage/
+
+# Debug files
+debug.log
+*.log
+
+# Local development settings
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Browser extensions
+# VS Code
+.vscode/
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# IntelliJ IDE
+.idea/
+
+# NetBeans
+nbproject/private/
+nbproject/project.bak
+nbproject/build-impl.xml
+nbproject/genfiles.properties
+nbproject/project.properties
+build/
+
+# Code::Blocks
+*.depend
+*.layout
+*.cbp
+
+# Dev-C++
+*.dev
+
+# Sublime Text
+*.sublime-workspace
+*.sublime-project
+
+# Vim
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+
+# Emacs
+*~
+\\#\\#*
+.\\#*
+*.elc
+auto-save-list
+tramp
+.\.emacs\.desktop
+.\.emacs\.desktop\.lock
+.\.project\.desktop
+.\.project\.desktop\.lock
+
+# Visual Studio
+*.user
+*.userosscache
+*.suo
+*.csproj.user
+*.csproj.userosscache
+*.vbproj.user
+*.vbproj.userosscache
+*.vcxproj.filters
+*.VC.db
+*.VC.VC.opendb
+*.VC.tagcache
+
+# Visual Studio Code
+.vscode/
+
+# Rider
+.idea/
+
+# Platform-specific files
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+`;
+    try {
+        // Write the .gitignore file
+        const result = await writeFile(projectName, gitignoreContent, '.gitignore');
+        if (Either.isLeft(result)) {
+            return result;
+        }
+        console.log('.gitignore file created successfully');
+        return Either.right(undefined);
+    }
+    catch (error) {
+        console.error('Failed to create .gitignore file:', error);
+        return Either.left(new Error(`Failed to create .gitignore file: ${error.message}`));
+    }
+};
+//# sourceMappingURL=process-fs-handler.js.map