swallowkit 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/cli/commands/init.js

@@ -37,11 +37,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initCommand = initCommand;
+exports.injectSwallowKitNextConfig = injectSwallowKitNextConfig;
+exports.buildCSharpFunctionsProgramSource = buildCSharpFunctionsProgramSource;
+exports.buildCSharpFunctionsProjectSource = buildCSharpFunctionsProjectSource;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const prompts_1 = __importDefault(require("prompts"));
 const package_manager_1 = require("../../utils/package-manager");
+const BACKEND_LANGUAGE_CHOICES = [
+    { title: "TypeScript", value: "typescript" },
+    { title: "C#", value: "csharp" },
+    { title: "Python", value: "python" },
+];
+function usesNodeFunctionsProject(backendLanguage) {
+    return backendLanguage === "typescript";
+}
+function getBackendLanguageLabel(backendLanguage) {
+    return BACKEND_LANGUAGE_CHOICES.find((choice) => choice.value === backendLanguage)?.title || backendLanguage;
+}
+function getFunctionsWorkerRuntime(backendLanguage) {
+    if (backendLanguage === "csharp") {
+        return "dotnet-isolated";
+    }
+    if (backendLanguage === "python") {
+        return "python";
+    }
+    return "node";
+}
+function getFunctionsRuntimeConfig(backendLanguage) {
+    if (backendLanguage === "csharp") {
+        return { name: "dotnet-isolated", version: "8.0" };
+    }
+    if (backendLanguage === "python") {
+        return { name: "python", version: "3.11" };
+    }
+    return { name: "node", version: "22" };
+}
+async function promptBackendLanguage() {
+    const response = await (0, prompts_1.default)({
+        type: "select",
+        name: "backendLanguage",
+        message: "Azure Functions backend language:",
+        choices: BACKEND_LANGUAGE_CHOICES,
+        initial: 0,
+    });
+    return response.backendLanguage || "typescript";
+}
 async function promptCiCd() {
     const response = await (0, prompts_1.default)({
         type: 'select',
@@ -83,6 +125,7 @@ async function promptAzureConfig() {
     };
 }
 const VALID_CICD = ['github', 'azure', 'skip'];
+const VALID_BACKEND_LANGUAGE = ['typescript', 'csharp', 'python'];
 const VALID_COSMOS_DB_MODE = ['freetier', 'serverless'];
 const VALID_VNET = ['none', 'outbound'];
 function validateInitFlags(options) {
@@ -90,6 +133,10 @@ function validateInitFlags(options) {
         console.error(`❌ Invalid --cicd value: "${options.cicd}". Must be: ${VALID_CICD.join(', ')}`);
         process.exit(1);
     }
+    if (options.backendLanguage && !VALID_BACKEND_LANGUAGE.includes(options.backendLanguage)) {
+        console.error(`❌ Invalid --backend-language value: "${options.backendLanguage}". Must be: ${VALID_BACKEND_LANGUAGE.join(', ')}`);
+        process.exit(1);
+    }
     if (options.cosmosDbMode && !VALID_COSMOS_DB_MODE.includes(options.cosmosDbMode)) {
         console.error(`❌ Invalid --cosmos-db-mode value: "${options.cosmosDbMode}". Must be: ${VALID_COSMOS_DB_MODE.join(', ')}`);
         process.exit(1);
@@ -117,6 +164,7 @@ async function initCommand(options) {
         }
         // Use flag values if provided, otherwise prompt interactively
         const cicdProvider = options.cicd || await promptCiCd();
+        const backendLanguage = options.backendLanguage || await promptBackendLanguage();
         const azureConfig = (options.cosmosDbMode && options.vnet)
             ? { cosmosDbMode: options.cosmosDbMode, vnetOption: options.vnet }
             : await promptAzureConfig();
@@ -125,15 +173,15 @@ async function initCommand(options) {
         // Upgrade Next.js to specified version (or latest) to avoid cached old versions
         await upgradeNextJs(projectDir, options.nextVersion || 'latest', pm);
         // Add SwallowKit specific files
-        await addSwallowKitFiles(projectDir, options, cicdProvider, azureConfig, pm);
+        await addSwallowKitFiles(projectDir, options, cicdProvider, azureConfig, pm, backendLanguage);
         // Create infrastructure files (Bicep)
-        await createInfrastructure(projectDir, options.name, azureConfig);
+        await createInfrastructure(projectDir, options.name, azureConfig, backendLanguage);
         // Create CI/CD files based on choice
         if (cicdProvider === 'github') {
-            await createGitHubActionsWorkflows(projectDir, azureConfig, pm);
+            await createGitHubActionsWorkflows(projectDir, azureConfig, pm, backendLanguage);
         }
         else if (cicdProvider === 'azure') {
-            await createAzurePipelines(projectDir, pm);
+            await createAzurePipelines(projectDir, pm, backendLanguage);
         }
         // Initialize Git repository and create initial commit
         try {
@@ -179,7 +227,7 @@ async function initCommand(options) {
         console.log("\n📝 Next steps:");
         console.log(`  cd ${options.name}`);
         console.log(`  ${pmCmd.dlx} swallowkit create-model <name>  # Create your first model`);
-        console.log(`  ${pmCmd.dlx} swallowkit scaffold lib/models/<name>.ts  # Generate CRUD code`);
+        console.log(`  ${pmCmd.dlx} swallowkit scaffold shared/models/<name>.ts  # Generate CRUD code`);
         console.log(`  ${pmCmd.dlx} swallowkit dev  # Start development servers`);
         console.log("\n🚀 Deploy to Azure:");
         console.log(`  ${pmCmd.dlx} swallowkit provision --resource-group <name>`);
@@ -285,7 +333,52 @@ async function installDependencies(projectDir, pm = 'pnpm') {
         });
     });
 }
-async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig, pm) {
+function injectSwallowKitNextConfig(nextConfigContent, projectName) {
+    return nextConfigContent.replace(/(const\s+nextConfig[:\s]*(?::\s*NextConfig\s*)?=\s*\{)(\s*\/\*[^*]*\*\/)?/, `$1\n  output: 'standalone',\n  transpilePackages: ['@${projectName}/shared'],\n  serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers'],$2`);
+}
+function buildCSharpFunctionsProgramSource() {
+    return `using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+var host = new HostBuilder()
+    .ConfigureFunctionsWorkerDefaults()
+    .ConfigureServices(services =>
+    {
+        services.AddApplicationInsightsTelemetryWorkerService();
+    })
+    .Build();
+
+host.Run();
+`;
+}
+function buildCSharpFunctionsProjectSource() {
+    return `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="generated\\**\\bin\\**\\*.cs;generated\\**\\obj\\**\\*.cs" />
+    <EmbeddedResource Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />
+    <None Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Cosmos" Version="3.47.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Azure.Identity" Version="1.13.2" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.23.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.2.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.18.0" OutputItemType="Analyzer" />
+    <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="1.2.0" />
+  </ItemGroup>
+</Project>
+`;
+}
+async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig, pm, backendLanguage) {
     console.log('📦 Adding SwallowKit files...\n');
     const projectName = options.name;
     // 1. Update package.json to add swallowkit and @azure/cosmos dependencies
@@ -300,11 +393,17 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
         'applicationinsights': '^3.3.0',
         [`@${projectName}/shared`]: '*',
     };
+    if (backendLanguage !== "typescript") {
+        packageJson.devDependencies = {
+            ...packageJson.devDependencies,
+            '@openapitools/openapi-generator-cli': '^2.21.0',
+        };
+    }
     packageJson.scripts = {
         ...packageJson.scripts,
         'build': (0, package_manager_1.getBuildScript)(pm),
         'start': 'next start',
-        'functions:start': (0, package_manager_1.getFunctionsStartScript)(pm),
+        'functions:start': (0, package_manager_1.getFunctionsStartScript)(pm, backendLanguage),
     };
     if (pm === 'pnpm') {
         packageJson.packageManager = 'pnpm@latest';
@@ -313,7 +412,8 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
         node: '20.x',
     };
     // Workspace configuration depends on package manager
-    const wsConfig = (0, package_manager_1.getWorkspaceConfig)(pm, ['shared', 'functions']);
+    const workspacePackages = usesNodeFunctionsProject(backendLanguage) ? ['shared', 'functions'] : ['shared'];
+    const wsConfig = (0, package_manager_1.getWorkspaceConfig)(pm, workspacePackages);
     if (wsConfig.type === 'file') {
         // pnpm: workspaces are defined in pnpm-workspace.yaml
         delete packageJson.workspaces;
@@ -336,11 +436,9 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
     }
     if (fs.existsSync(nextConfigPath)) {
         let nextConfigContent = fs.readFileSync(nextConfigPath, 'utf-8');
-        // Add output: 'standalone', experimental.turbopackUseSystemTlsCerts, and serverExternalPackages
+        // Add output, transpiled workspace package, and server externals for standalone deployment
         if (!nextConfigContent.includes("output:") && !nextConfigContent.includes('output =')) {
-            // Handle TypeScript config format: const nextConfig: NextConfig = {
-            // Handle JavaScript config format: const nextConfig = {
-            nextConfigContent = nextConfigContent.replace(/(const\s+nextConfig[:\s]*(?::\s*NextConfig\s*)?=\s*\{)(\s*\/\*[^*]*\*\/)?/, `$1\n  output: 'standalone',\n  transpilePackages: ['@${projectName}/shared'],\n  experimental: {\n    turbopackUseSystemTlsCerts: true,\n  },\n  serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers'],$2`);
+            nextConfigContent = injectSwallowKitNextConfig(nextConfigContent, projectName);
             fs.writeFileSync(nextConfigPath, nextConfigContent);
         }
     }
@@ -362,8 +460,11 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
     // 3. Create SwallowKit config
     const swallowkitConfig = `/** @type {import('swallowkit').SwallowKitConfig} */
 module.exports = {
+  backend: {
+    language: '${backendLanguage}',
+  },
   functions: {
-    baseUrl: process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
+    baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
   },
   deployment: {
     resourceGroup: process.env.AZURE_RESOURCE_GROUP || '',
@@ -382,7 +483,7 @@ module.exports = {
     // Create backend utility for calling Azure Functions
     const backendUtilContent = `// Get Functions base URL at runtime (not at build time)
 function getFunctionsBaseUrl(): string {
-  return process.env.BACKEND_FUNCTIONS_BASE_URL || 'http://localhost:7071';
+  return process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071';
 }
 
 /**
@@ -487,7 +588,7 @@ export const api = {
     fs.mkdirSync(componentsDir, { recursive: true });
     // 6. Create .env.example
     const envExample = `# Azure Functions Backend URL
-FUNCTIONS_BASE_URL=http://localhost:7071
+BACKEND_FUNCTIONS_BASE_URL=http://localhost:7071
 
 # Azure Configuration
 AZURE_RESOURCE_GROUP=your-resource-group
@@ -570,7 +671,7 @@ export async function register() {
     // 8. Create .env.local for local development
     const envLocalContent = [
         '# Azure Functions Backend URL (Local)',
-        'FUNCTIONS_BASE_URL=http://localhost:7071',
+        'BACKEND_FUNCTIONS_BASE_URL=http://localhost:7071',
         ''
     ].join('\n');
     fs.writeFileSync(path.join(projectDir, '.env.local'), envLocalContent);
@@ -596,7 +697,7 @@ export async function register() {
     };
     fs.writeFileSync(path.join(projectDir, 'staticwebapp.config.json'), JSON.stringify(swaConfig, null, 2));
     // 14. Create Azure Functions project
-    await createAzureFunctionsProject(projectDir, pm);
+    await createAzureFunctionsProject(projectDir, pm, backendLanguage);
     // 15. Create BFF API route to call Azure Functions
     await createBffApiRoute(projectDir);
     // 16. Create home page
@@ -606,9 +707,9 @@ export async function register() {
     await installDependencies(projectDir, pm);
     console.log('✅ Project structure created\n');
     // 18. Create README.md
-    createReadme(projectDir, projectName, cicdChoice, azureConfig, pm);
+    createReadme(projectDir, projectName, cicdChoice, azureConfig, pm, backendLanguage);
     // 19. Create AI agent instruction files (AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, etc.)
-    createAiAgentFiles(projectDir, projectName);
+    createAiAgentFiles(projectDir, projectName, backendLanguage);
 }
 async function createSharedPackage(projectDir, projectName) {
     console.log('📦 Creating shared workspace package for Zod models...\n');
@@ -661,11 +762,93 @@ async function createSharedPackage(projectDir, projectName) {
     fs.writeFileSync(path.join(sharedDir, '.gitignore'), `node_modules\ndist\n`);
     console.log('✅ Shared package created\n');
 }
-async function createAzureFunctionsProject(projectDir, pm = 'pnpm') {
-    console.log('📦 Creating Azure Functions project...\n');
+async function createAzureFunctionsProject(projectDir, pm = 'pnpm', backendLanguage = 'typescript') {
+    console.log(`📦 Creating Azure Functions project (${getBackendLanguageLabel(backendLanguage)})...\n`);
     const functionsDir = path.join(projectDir, 'functions');
     fs.mkdirSync(functionsDir, { recursive: true });
-    // Create functions package.json
+    const projectName = path.basename(projectDir);
+    const databaseName = `${projectName.charAt(0).toUpperCase() + projectName.slice(1)}Database`;
+    createFunctionsHostFiles(functionsDir, databaseName, backendLanguage);
+    if (backendLanguage === 'typescript') {
+        createTypeScriptFunctionsProject(projectDir, functionsDir, pm);
+    }
+    else if (backendLanguage === 'csharp') {
+        createCSharpFunctionsProject(projectDir, functionsDir);
+    }
+    else {
+        createPythonFunctionsProject(projectDir, functionsDir);
+    }
+    console.log('✅ Azure Functions project created\n');
+}
+function createFunctionsHostFiles(functionsDir, databaseName, backendLanguage) {
+    const hostJson = {
+        version: '2.0',
+        logging: {
+            applicationInsights: {
+                samplingSettings: {
+                    isEnabled: true,
+                    maxTelemetryItemsPerSecond: 20,
+                },
+            },
+        },
+        extensionBundle: {
+            id: 'Microsoft.Azure.Functions.ExtensionBundle',
+            version: '[4.0.0, 4.10.0)',
+        },
+    };
+    fs.writeFileSync(path.join(functionsDir, 'host.json'), JSON.stringify(hostJson, null, 2));
+    const localSettings = {
+        IsEncrypted: false,
+        Values: {
+            AzureWebJobsStorage: '',
+            FUNCTIONS_WORKER_RUNTIME: getFunctionsWorkerRuntime(backendLanguage),
+            AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
+            CosmosDBConnection: 'AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==',
+            COSMOS_DB_DATABASE_NAME: databaseName,
+            NODE_TLS_REJECT_UNAUTHORIZED: '0',
+        },
+    };
+    fs.writeFileSync(path.join(functionsDir, 'local.settings.json'), JSON.stringify(localSettings, null, 2));
+    const gitignoreLines = [
+        'local.settings.json',
+        '*.log',
+        '.vscode',
+        '.DS_Store',
+    ];
+    if (backendLanguage === 'typescript') {
+        gitignoreLines.unshift('node_modules', 'dist');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `node_modules
+.git
+.vscode
+local.settings.json
+test
+tsconfig.json
+*.ts
+!dist/**/*.js
+`);
+    }
+    else if (backendLanguage === 'python') {
+        gitignoreLines.unshift('.venv', '__pycache__', '.python_packages');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `.venv
+__pycache__
+.pytest_cache
+.mypy_cache
+.ruff_cache
+local.settings.json
+tests
+`);
+    }
+    else {
+        gitignoreLines.unshift('bin', 'obj');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `bin
+obj
+local.settings.json
+tests
+`);
+    }
+    fs.writeFileSync(path.join(functionsDir, '.gitignore'), `${gitignoreLines.join('\n')}\n`);
+}
+function createTypeScriptFunctionsProject(projectDir, functionsDir, pm) {
     const functionsPackageJson = {
         name: 'functions',
         version: '1.0.0',
@@ -674,22 +857,21 @@ async function createAzureFunctionsProject(projectDir, pm = 'pnpm') {
         scripts: {
             start: 'func start',
             build: 'tsc',
-            prestart: (0, package_manager_1.getFunctionsPrestart)(pm)
+            prestart: (0, package_manager_1.getFunctionsPrestart)(pm),
         },
         dependencies: {
             '@azure/functions': '~4.5.0',
             '@azure/cosmos': '^4.0.0',
             '@azure/identity': '^4.0.0',
-            'zod': '>=3.25.0',
+            zod: '>=3.25.0',
             [`@${path.basename(projectDir)}/shared`]: '*',
         },
         devDependencies: {
             '@types/node': '^20.0.0',
-            'typescript': '^5.0.0'
-        }
+            typescript: '^5.0.0',
+        },
     };
     fs.writeFileSync(path.join(functionsDir, 'package.json'), JSON.stringify(functionsPackageJson, null, 2));
-    // Create functions tsconfig.json
     const sharedPkgName = `@${path.basename(projectDir)}/shared`;
     const functionsTsConfig = {
         compilerOptions: {
@@ -709,69 +891,14 @@ async function createAzureFunctionsProject(projectDir, pm = 'pnpm') {
             },
         },
         include: ['src/**/*'],
-        exclude: ['node_modules', 'dist']
+        exclude: ['node_modules', 'dist'],
     };
     fs.writeFileSync(path.join(functionsDir, 'tsconfig.json'), JSON.stringify(functionsTsConfig, null, 2));
-    // Create host.json
-    const hostJson = {
-        version: '2.0',
-        logging: {
-            applicationInsights: {
-                samplingSettings: {
-                    isEnabled: true,
-                    maxTelemetryItemsPerSecond: 20
-                }
-            }
-        },
-        extensionBundle: {
-            id: 'Microsoft.Azure.Functions.ExtensionBundle',
-            version: '[4.0.0, 4.10.0)'
-        }
-    };
-    fs.writeFileSync(path.join(functionsDir, 'host.json'), JSON.stringify(hostJson, null, 2));
-    // Create .funcignore
-    const funcignore = `node_modules
-.git
-.vscode
-local.settings.json
-test
-tsconfig.json
-*.ts
-!dist/**/*.js
-`;
-    fs.writeFileSync(path.join(functionsDir, '.funcignore'), funcignore);
-    // Create .gitignore for functions directory
-    const functionsGitignore = `node_modules
-dist
-local.settings.json
-*.log
-.vscode
-.DS_Store
-`;
-    fs.writeFileSync(path.join(functionsDir, '.gitignore'), functionsGitignore);
-    // Create local.settings.json
-    const projectName = path.basename(projectDir);
-    const databaseName = `${projectName.charAt(0).toUpperCase() + projectName.slice(1)}Database`;
-    const localSettings = {
-        IsEncrypted: false,
-        Values: {
-            AzureWebJobsStorage: '',
-            FUNCTIONS_WORKER_RUNTIME: 'node',
-            AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
-            CosmosDBConnection: 'AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==',
-            COSMOS_DB_DATABASE_NAME: databaseName,
-            NODE_TLS_REJECT_UNAUTHORIZED: '0'
-        }
-    };
-    fs.writeFileSync(path.join(functionsDir, 'local.settings.json'), JSON.stringify(localSettings, null, 2));
-    // Create src directory
     const srcDir = path.join(functionsDir, 'src');
     fs.mkdirSync(srcDir, { recursive: true });
-    // Create greet function directly in src
-    const greetFunction = `import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+    fs.writeFileSync(path.join(srcDir, 'greet.ts'), `import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
 import { z } from 'zod/v4';
 
-// Zod schema for request validation
 const greetRequestSchema = z.object({
   name: z.string().min(1, 'Name is required').max(50, 'Name must be less than 50 characters'),
 });
@@ -780,12 +907,9 @@ export async function greet(request: HttpRequest, context: InvocationContext): P
   context.log('HTTP trigger function processed a request.');
 
   try {
-    // Get name from query or body
     const name = request.query.get('name') || (await request.text());
-    
-    // Validate with Zod
     const result = greetRequestSchema.safeParse({ name });
-    
+
     if (!result.success) {
       return {
         status: 400,
@@ -796,7 +920,7 @@ export async function greet(request: HttpRequest, context: InvocationContext): P
     }
 
     const greeting = \`Hello, \${result.data.name}! This message is from Azure Functions.\`;
-    
+
     return {
       status: 200,
       jsonBody: {
@@ -820,10 +944,89 @@ app.http('greet', {
   authLevel: 'anonymous',
   handler: greet
 });
-`;
-    fs.writeFileSync(path.join(srcDir, 'greet.ts'), greetFunction);
-    // Dependencies are installed via workspace root install
-    console.log('✅ Azure Functions project created\n');
+`);
+}
+function createCSharpFunctionsProject(projectDir, functionsDir) {
+    const projectBaseName = path.basename(projectDir);
+    const projectPascal = projectBaseName.charAt(0).toUpperCase() + projectBaseName.slice(1);
+    const csprojName = `${projectPascal}.Functions.csproj`;
+    fs.writeFileSync(path.join(functionsDir, csprojName), buildCSharpFunctionsProjectSource());
+    fs.writeFileSync(path.join(functionsDir, 'Program.cs'), buildCSharpFunctionsProgramSource());
+    const crudDir = path.join(functionsDir, 'Crud');
+    fs.mkdirSync(crudDir, { recursive: true });
+    fs.writeFileSync(path.join(crudDir, 'GreetFunction.cs'), `using System.Net;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+
+namespace SwallowKit.Functions;
+
+public sealed class GreetFunction
+{
+    [Function("greet")]
+    public async Task<HttpResponseData> Run(
+        [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "greet")] HttpRequestData request)
+    {
+        var query = request.Url.Query.TrimStart('?').Split('&', StringSplitOptions.RemoveEmptyEntries);
+        var name = "SwallowKit";
+        foreach (var segment in query)
+        {
+            var parts = segment.Split('=', 2);
+            if (parts.Length == 2 && parts[0] == "name")
+            {
+                name = Uri.UnescapeDataString(parts[1]);
+                break;
+            }
+        }
+        var response = request.CreateResponse(HttpStatusCode.OK);
+        await response.WriteAsJsonAsync(new
+        {
+            message = $"Hello, {name}! This message is from Azure Functions.",
+            timestamp = DateTimeOffset.UtcNow.ToString("O"),
+        });
+        return response;
+    }
+}
+`);
+}
+function createPythonFunctionsProject(projectDir, functionsDir) {
+    fs.writeFileSync(path.join(projectDir, '.python-version'), '3.11\n');
+    fs.writeFileSync(path.join(functionsDir, 'requirements.txt'), `azure-functions>=1.20.0
+azure-cosmos>=4.9.0
+azure-identity>=1.19.0
+`);
+    const blueprintsDir = path.join(functionsDir, 'blueprints');
+    fs.mkdirSync(blueprintsDir, { recursive: true });
+    fs.writeFileSync(path.join(blueprintsDir, '__init__.py'), '');
+    fs.writeFileSync(path.join(blueprintsDir, 'greet.py'), `import json
+from datetime import datetime, timezone
+
+import azure.functions as func
+
+bp = func.Blueprint()
+
+
+@bp.route(route="greet", methods=["GET", "POST"])
+def greet(req: func.HttpRequest) -> func.HttpResponse:
+    name = req.params.get("name") or "SwallowKit"
+    payload = {
+        "message": f"Hello, {name}! This message is from Azure Functions.",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+    return func.HttpResponse(
+        body=json.dumps(payload, ensure_ascii=False),
+        status_code=200,
+        mimetype="application/json",
+    )
+`);
+    fs.writeFileSync(path.join(functionsDir, 'function_app.py'), `import azure.functions as func
+
+from blueprints.greet import bp as greet_bp
+
+app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)
+
+app.register_blueprint(greet_bp)
+# SwallowKit scaffold registrations
+`);
 }
 async function createBffApiRoute(projectDir) {
     console.log('📦 Creating BFF API route...\n');
@@ -874,17 +1077,17 @@ export async function POST(request: NextRequest) {
 }
 `;
     fs.writeFileSync(path.join(apiDir, 'route.ts'), apiRoute);
-    // Update .env.example to include FUNCTIONS_BASE_URL
+    // Update .env.example to include BACKEND_FUNCTIONS_BASE_URL
     const envExamplePath = path.join(projectDir, '.env.example');
     let envExample = fs.readFileSync(envExamplePath, 'utf-8');
-    if (!envExample.includes('FUNCTIONS_BASE_URL')) {
+    if (!envExample.includes('BACKEND_FUNCTIONS_BASE_URL')) {
         envExample += `\n# Azure Functions Backend URL\nBACKEND_FUNCTIONS_BASE_URL=http://localhost:7071\n`;
         fs.writeFileSync(envExamplePath, envExample);
     }
     // Update .env.local
     const envLocalPath = path.join(projectDir, '.env.local');
     let envLocal = fs.readFileSync(envLocalPath, 'utf-8');
-    if (!envLocal.includes('FUNCTIONS_BASE_URL')) {
+    if (!envLocal.includes('BACKEND_FUNCTIONS_BASE_URL')) {
         envLocal += `\n# Azure Functions Backend URL (Local)\nBACKEND_FUNCTIONS_BASE_URL=http://localhost:7071\n`;
         fs.writeFileSync(envLocalPath, envLocal);
     }
@@ -985,7 +1188,7 @@ export default function Home() {
                 Create your first model with Zod and generate CRUD operations automatically.
               </p>
               <code className="block bg-gray-100 dark:bg-gray-900 p-4 rounded text-left text-sm">
-                ${pmCmd.dlx} swallowkit scaffold lib/models/your-model.ts
+                ${pmCmd.dlx} swallowkit scaffold shared/models/your-model.ts
               </code>
             </div>
           </section>
@@ -1021,13 +1224,28 @@ export const scaffoldConfig = {
     fs.writeFileSync(path.join(scaffoldConfigDir, 'scaffold-config.ts'), scaffoldConfigContent);
     console.log('✅ Scaffold config created\n');
 }
-function createReadme(projectDir, projectName, cicdChoice, azureConfig, pm) {
+function createReadme(projectDir, projectName, cicdChoice, azureConfig, pm, backendLanguage) {
     console.log('📝 Creating README.md...\n');
     const pmCmd = (0, package_manager_1.getCommands)(pm);
     const cosmosDbModeLabel = azureConfig.cosmosDbMode === 'freetier' ? 'Free Tier (1000 RU/s)' : 'Serverless';
     const cicdLabel = cicdChoice === 'github' ? 'GitHub Actions' : cicdChoice === 'azure' ? 'Azure Pipelines' : 'None';
     const vnetLabel = azureConfig.vnetOption === 'none' ? 'None (public endpoints)' :
         'Outbound VNet (Cosmos DB Private Endpoint)';
+    const backendLanguageLabel = getBackendLanguageLabel(backendLanguage);
+    const schemaBridgeDescription = backendLanguage === 'typescript'
+        ? 'Zod (shared between frontend and backend)'
+        : `Zod + OpenAPI bridge (Zod in shared/, generated ${backendLanguageLabel} schemas in functions/generated/)`;
+    const functionsTree = backendLanguage === 'typescript'
+        ? `│   └── src/\n│       └── greet.ts      # Sample function`
+        : backendLanguage === 'csharp'
+            ? `│   ├── Crud/\n│   │   └── GreetFunction.cs\n│   └── generated/       # OpenAPI-derived C# models`
+            : `│   ├── blueprints/\n│   │   └── greet.py\n│   └── generated/       # OpenAPI-derived Python models`;
+    const backendScaffoldNote = backendLanguage === 'typescript'
+        ? '- Azure Functions CRUD endpoints'
+        : `- Azure Functions ${backendLanguageLabel} CRUD handlers\n- OpenAPI spec + generated ${backendLanguageLabel} schema assets`;
+    const pythonLocalDevNote = backendLanguage === 'python'
+        ? `\n**Python local dev note**: SwallowKit uses \`functions/.venv\` for local Azure Functions development. If \`uv\` is installed, \`swallowkit dev\` uses it to create/manage that virtual environment; otherwise it falls back to the standard \`venv\` + \`pip\` workflow. Keep \`functions/requirements.txt\` as the dependency source of truth for Azure Functions compatibility.\n`
+        : '';
     const readme = `# ${projectName}
 
 A full-stack application built with **SwallowKit** - Next.js on Azure Static Web Apps + Functions + Cosmos DB with Zod schema sharing.
@@ -1036,9 +1254,9 @@ A full-stack application built with **SwallowKit** - Next.js on Azure Static Web
 
 - **Frontend**: Next.js 15 (App Router), React, TypeScript, Tailwind CSS
 - **BFF (Backend for Frontend)**: Next.js API Routes
-- **Backend**: Azure Functions (TypeScript)
+- **Backend**: Azure Functions (${backendLanguageLabel})
 - **Database**: Azure Cosmos DB
-- **Schema Validation**: Zod (shared between frontend and backend)
+- **Schema Validation**: ${schemaBridgeDescription}
 - **Infrastructure**: Bicep (Infrastructure as Code)
 - **CI/CD**: ${cicdLabel}
 
@@ -1073,11 +1291,8 @@ ${projectName}/
 │   ├── api/               # BFF API routes (proxy to Functions)
 │   └── page.tsx           # Home page
 ├── functions/             # Azure Functions (backend)
-│   └── src/
-│       ├── models/        # Data models (copied from lib/models)
-│       └── hello.ts       # Sample function
+${functionsTree}
 ├── lib/
-│   ├── models/            # Shared Zod schemas
 │   └── api/               # API client utilities
 ├── infra/                 # Bicep infrastructure files
 │   ├── main.bicep
@@ -1095,18 +1310,18 @@ Define your data model with Zod schema:
 ${pmCmd.dlx} swallowkit create-model <model-name>
 \`\`\`
 
-This creates a model file in \`lib/models/<model-name>.ts\`. Edit it to define your schema.
+This creates a model file in \`shared/models/<model-name>.ts\`. Edit it to define your schema.
 
 ### 2. Generate CRUD Code
 
 Generate complete CRUD operations (Functions, API routes, UI):
 
 \`\`\`bash
-${pmCmd.dlx} swallowkit scaffold lib/models/<model-name>.ts
+${pmCmd.dlx} swallowkit scaffold shared/models/<model-name>.ts
 \`\`\`
 
 This generates:
-- Azure Functions CRUD endpoints
+${backendScaffoldNote}
 - Next.js BFF API routes
 - React UI components (list, detail, create, edit)
 - Navigation menu integration
@@ -1123,6 +1338,7 @@ This starts:
 - Cosmos DB Emulator check (must be running separately)
 
 **Note**: You need to start Cosmos DB Emulator manually before running \`swallowkit dev\`.
+${pythonLocalDevNote}
 
 ## ☁️ Deploy to Azure
 
@@ -1237,8 +1453,20 @@ This project was generated by SwallowKit. If you encounter any issues or have su
     fs.writeFileSync(path.join(projectDir, 'README.md'), readme);
     console.log('✅ README.md created\n');
 }
-function createAiAgentFiles(projectDir, projectName) {
+function createAiAgentFiles(projectDir, projectName, backendLanguage) {
     console.log('🤖 Creating AI agent instruction files...\n');
+    const backendLanguageLabel = getBackendLanguageLabel(backendLanguage);
+    const functionsStructureLine = backendLanguage === 'typescript'
+        ? `│   └── src/               # HTTP trigger handlers with Cosmos DB bindings`
+        : backendLanguage === 'csharp'
+            ? `│   ├── Crud/              # C# HTTP trigger handlers\n│   └── generated/         # OpenAPI-derived C# schema assets`
+            : `│   ├── blueprints/        # Python HTTP trigger handlers\n│   └── generated/         # OpenAPI-derived Python schema assets`;
+    const backendSchemaNote = backendLanguage === 'typescript'
+        ? `- The shared package (\`@${projectName}/shared\`) is consumed by both Next.js and Azure Functions as a workspace dependency.`
+        : `- The frontend/BFF source of truth stays in \`shared/models/\` as Zod schemas.\n- \`swallowkit scaffold\` exports OpenAPI into \`functions/openapi/\` and generates ${backendLanguageLabel} schema assets into \`functions/generated/\` for backend use.`;
+    const backendRulesNote = backendLanguage === 'typescript'
+        ? `- All CRUD operations and business logic live in \`functions/src/\`.\n- Use Azure Functions Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.\n- Use the Cosmos DB SDK client directly **only** for delete operations (bindings do not support delete).\n- Validate all data against Zod schemas before writing to Cosmos DB.\n- The backend auto-generates \`id\` (UUID), \`createdAt\`, and \`updatedAt\` — never trust client-sent values for these fields.`
+        : `- All business logic lives in \`functions/\` and the generated handlers perform real Cosmos DB CRUD.\n- Keep Zod schemas in \`shared/models/\` as the source of truth.\n- Regenerate backend contracts with \`swallowkit scaffold shared/models/<name>.ts\` whenever a schema changes.\n- Use the generated OpenAPI-derived models in \`functions/generated/\` to keep backend contracts aligned.\n- The backend should still own \`id\`, \`createdAt\`, and \`updatedAt\`.`;
     // ── 1. AGENTS.md (Codex / generic agents) ──────────────────────────
     const agentsMd = `# AGENTS.md
 
@@ -1247,14 +1475,14 @@ All coding agents **must** follow the architecture and conventions described bel
 
 ## Architecture Overview
 
-This is a full-stack TypeScript application deployed on Azure with the following layers:
+This is a full-stack application deployed on Azure with a TypeScript frontend/BFF and an Azure Functions backend in ${backendLanguageLabel}.
 
 \`\`\`
 Frontend (React / Next.js App Router)
   ↓ fetch('/api/{model}', ...)
 BFF Layer (Next.js API Routes)
   ↓ HTTP → Azure Functions
-Backend (Azure Functions with Cosmos DB bindings)
+Backend (Azure Functions)
   ↓
 Azure Cosmos DB (Document Database)
 \`\`\`
@@ -1267,7 +1495,7 @@ ${projectName}/
 │   ├── api/               # BFF API routes (proxy to Azure Functions)
 │   └── {model}/           # UI pages per model (list, detail, create, edit)
 ├── functions/             # Azure Functions (backend)
-│   └── src/               # HTTP trigger handlers with Cosmos DB bindings
+${functionsStructureLine}
 ├── shared/                # Shared workspace package
 │   ├── models/            # Zod schema definitions (single source of truth)
 │   └── index.ts           # Re-exports all models
@@ -1322,8 +1550,7 @@ export async function POST(request: NextRequest) {
 
 - All data models are defined **once** as Zod schemas in \`shared/models/\`.
 - TypeScript types are derived with \`z.infer<typeof Schema>\` — never define types separately.
-- The same schema is used in **all three layers**: frontend (validation), BFF (input/output validation), and Azure Functions (request/response validation + Cosmos DB documents).
-- The shared package (\`@${projectName}/shared\`) is consumed by both Next.js and Azure Functions as a workspace dependency.
+- ${backendSchemaNote}
 
 Model definition pattern:
 
@@ -1350,15 +1577,11 @@ Key rules:
 
 ### 3. Azure Functions Own All Business Logic and Data Access
 
-- All CRUD operations and business logic live in \`functions/src/\`.
-- Use Azure Functions Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
-- Use the Cosmos DB SDK client directly **only** for delete operations (bindings do not support delete).
-- Validate all data against Zod schemas before writing to Cosmos DB.
-- The backend auto-generates \`id\` (UUID), \`createdAt\`, and \`updatedAt\` — never trust client-sent values for these fields.
+- ${backendRulesNote}
 
-Azure Functions handler pattern:
+${backendLanguage === 'typescript' ? 'Azure Functions handler pattern:' : `Generated ${backendLanguageLabel} handlers live under \`functions/\`. Re-run \`swallowkit scaffold shared/models/<name>.ts\` after schema changes to keep generated CRUD handlers and \`functions/generated/\` in sync.`}
 
-\`\`\`typescript
+${backendLanguage === 'typescript' ? `\`\`\`typescript
 // functions/src/{model}.ts
 import { app } from '@azure/functions';
 import { ModelSchema } from '@${projectName}/shared';
@@ -1376,7 +1599,7 @@ app.http('{model}-get-all', {
     return { status: 200, jsonBody: validated };
   },
 });
-\`\`\`
+\`\`\`` : ''}
 
 ## Naming Conventions
 
@@ -1384,7 +1607,7 @@ app.http('{model}-get-all', {
 |------|-----------|---------|
 | Model schema file | \`shared/models/{kebab-case}.ts\` | \`shared/models/todo.ts\` |
 | Schema/type name | PascalCase (same name for both) | \`export const Todo = z.object({...}); export type Todo = z.infer<typeof Todo>;\` |
-| Functions handler file | \`functions/src/{kebab-case}.ts\` | \`functions/src/todo.ts\` |
+| Functions handler file | backend-language specific under \`functions/\` | \`${backendLanguage === 'typescript' ? 'functions/src/todo.ts' : backendLanguage === 'csharp' ? 'functions/Crud/TodoFunctions.cs' : 'functions/blueprints/todo.py'}\` |
 | Functions handler name | \`{camelCase}-{operation}\` | \`todo-get-all\`, \`todo-create\` |
 | API route path | \`/api/{camelCase}\` | \`/api/todo\`, \`/api/todo/{id}\` |
 | BFF route file | \`app/api/{kebab-case}/route.ts\` | \`app/api/todo/route.ts\` |
@@ -1417,7 +1640,7 @@ npx swallowkit scaffold shared/models/<name>.ts
 \`\`\`
 
 Generates:
-- Azure Functions handlers (\`functions/src/<name>.ts\`)
+- Azure Functions handlers (${backendLanguage === 'typescript' ? '\`functions/src/<name>.ts\`' : '\`functions/\` language-specific CRUD files + \`functions/generated/\` schema assets'})
 - BFF API routes (\`app/api/<name>/route.ts\`, \`app/api/<name>/[id]/route.ts\`)
 - UI pages (\`app/<name>/page.tsx\`, detail, create, edit pages)
 - Cosmos DB Bicep container config (\`infra/containers/<name>-container.bicep\`)
@@ -1459,7 +1682,7 @@ Deploys Bicep infrastructure: Static Web Apps, Functions, Cosmos DB, Storage, Ma
 
 - **Frontend**: Next.js (App Router), React, TypeScript, Tailwind CSS
 - **BFF**: Next.js API Routes (proxy only)
-- **Backend**: Azure Functions (TypeScript, Node.js)
+- **Backend**: Azure Functions (${backendLanguageLabel})
 - **Database**: Azure Cosmos DB (NoSQL)
 - **Schema**: Zod (shared across all layers via workspace package)
 - **Infrastructure**: Bicep (IaC)
@@ -1479,7 +1702,8 @@ This file is for Claude Code. Read AGENTS.md in the project root for the full ar
 - **Architecture**: Next.js (frontend) → BFF (API routes, proxy only) → Azure Functions (backend) → Cosmos DB
 - **Schema**: Zod schemas in \`shared/models/\` are the single source of truth. Never define types separately.
 - **BFF rule**: \`app/api/\` routes must ONLY proxy to Azure Functions via \`callFunction()\`. No business logic.
-- **Backend rule**: All business logic and Cosmos DB access lives in \`functions/src/\`.
+- **Backend language**: ${backendLanguageLabel}
+- **Backend rule**: Regenerate backend contracts with \`swallowkit scaffold\` after schema changes and keep \`functions/generated/\` in sync.
 
 ## SwallowKit CLI Commands
 
@@ -1516,13 +1740,13 @@ Frontend (Next.js App Router) → BFF (Next.js API Routes) → Backend (Azure Fu
 
 1. **BFF is proxy only** — \`app/api/\` routes call Azure Functions via \`callFunction()\`. No business logic, no direct DB access.
 2. **Zod = single source of truth** — Models live in \`shared/models/\`. Types are derived with \`z.infer<>\`. Never define types separately.
-3. **Backend owns data** — All CRUD, business logic, and Cosmos DB access is in \`functions/src/\`.
+3. **Backend owns data** — All CRUD and business logic stay in \`functions/\`, and generated contract assets under \`functions/generated/\` must stay aligned with \`shared/models/\`.
 4. **Use the CLI** — Run \`npx swallowkit create-model <name>\` then \`npx swallowkit scaffold shared/models/<name>.ts\` to add models. Do not create boilerplate manually.
 
 ## Naming
 
 - Schema/type: PascalCase, same name for both (\`export const Todo = z.object({...}); export type Todo = z.infer<typeof Todo>;\`)
-- Files: kebab-case (\`shared/models/todo.ts\`, \`functions/src/todo.ts\`)
+- Files: kebab-case (\`shared/models/todo.ts\`, backend handlers under \`functions/\`)
 - Cosmos DB containers: PascalCase + 's' (\`Todos\`), partition key always \`/id\`
 
 ## Managed Fields
@@ -1598,13 +1822,13 @@ applyTo: "functions/**"
 
 # Azure Functions — Backend Rules
 
-Files in \`functions/src/\` contain all business logic and data access for this application.
+Files in \`functions/\` contain all business logic and data access for this application.
 
 ## Rules
 
-- Use Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
-- Use the Cosmos DB SDK client directly **only** for delete operations.
-- Validate all request data against Zod schemas from \`@${projectName}/shared\` before writing.
+- Keep backend contracts aligned with \`shared/models/\` by rerunning \`swallowkit scaffold\` after schema changes.
+- For TypeScript backends, use Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
+- For C#/Python backends, consume the generated OpenAPI-derived assets in \`functions/generated/\`.
 - Auto-generate \`id\` (UUID), \`createdAt\`, and \`updatedAt\` on the backend. Never trust client-sent values.
 - Container names are PascalCase + 's' (e.g., \`Todos\`). Partition key is always \`/id\`.
 
@@ -1640,12 +1864,13 @@ app.http('{model}-get-all', {
     console.log('   - GitHub Copilot (edit) → .github/instructions/*.instructions.md');
     console.log('');
 }
-async function createInfrastructure(projectDir, projectName, azureConfig) {
+async function createInfrastructure(projectDir, projectName, azureConfig, backendLanguage) {
     console.log('📦 Creating infrastructure files (Bicep)...\n');
     const infraDir = path.join(projectDir, 'infra');
     const modulesDir = path.join(infraDir, 'modules');
     fs.mkdirSync(modulesDir, { recursive: true });
     const enableVNet = azureConfig.vnetOption !== 'none';
+    const functionsRuntime = getFunctionsRuntimeConfig(backendLanguage);
     // main.bicep
     const mainBicep = `targetScope = 'resourceGroup'
 
@@ -1756,16 +1981,18 @@ module cosmosPrivateEndpoint 'modules/private-endpoint-cosmos.bicep' = if (enabl
 // Azure Functions (Flex Consumption) - Deploy AFTER Cosmos DB
 module functionsFlex 'modules/functions-flex.bicep' = {
   name: 'functionsApp'
-  params: {
-    name: 'func-\${projectName}'
-    location: location
-    storageAccountName: 'stg\${uniqueString(resourceGroup().id, projectName)}'
-    appInsightsConnectionString: appInsightsFunctions.outputs.connectionString
-    swaDefaultHostname: staticWebApp.outputs.defaultHostname
-    cosmosDbEndpoint: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.endpoint : cosmosDbServerless.outputs.endpoint
-    cosmosDbDatabaseName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.databaseName : cosmosDbServerless.outputs.databaseName
-    enableVNet: enableVNet
-    vnetSubnetId: enableVNet ? vnet.outputs.functionsSubnetId : ''
+    params: {
+      name: 'func-\${projectName}'
+      location: location
+      storageAccountName: 'stg\${uniqueString(resourceGroup().id, projectName)}'
+      appInsightsConnectionString: appInsightsFunctions.outputs.connectionString
+      swaDefaultHostname: staticWebApp.outputs.defaultHostname
+      cosmosDbEndpoint: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.endpoint : cosmosDbServerless.outputs.endpoint
+      cosmosDbDatabaseName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.databaseName : cosmosDbServerless.outputs.databaseName
+      functionsRuntimeName: '${functionsRuntime.name}'
+      functionsRuntimeVersion: '${functionsRuntime.version}'
+      enableVNet: enableVNet
+      vnetSubnetId: enableVNet ? vnet.outputs.functionsSubnetId : ''
   }
   dependsOn: [
     cosmosDbFreeTier
@@ -1996,6 +2223,12 @@ param enableVNet bool = false
 @description('VNet subnet ID for Functions (required if enableVNet is true)')
 param vnetSubnetId string = ''
 
+@description('Functions runtime name')
+param functionsRuntimeName string
+
+@description('Functions runtime version')
+param functionsRuntimeVersion string
+
 // Storage Account for Functions
 resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
   name: storageAccountName
@@ -2066,8 +2299,8 @@ resource functionApp 'Microsoft.Web/sites@2023-12-01' = {
         instanceMemoryMB: 2048
       }
       runtime: {
-        name: 'node'
-        version: '22'
+        name: functionsRuntimeName
+        version: functionsRuntimeVersion
       }
     }
     siteConfig: {
@@ -2409,68 +2642,77 @@ output privateDnsZoneId string = privateDnsZone.id
     }
     console.log('✅ Infrastructure files created\n');
 }
-async function createGitHubActionsWorkflows(projectDir, azureConfig, pm) {
-    console.log('📦 Creating GitHub Actions workflows...\n');
+function getGitHubFunctionsWorkflow(pm, backendLanguage) {
     const pmCmd = (0, package_manager_1.getCommands)(pm);
     const pnpmSetupStep = (0, package_manager_1.getCiSetupStep)(pm);
-    const workflowsDir = path.join(projectDir, '.github', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-    // deploy-swa.yml
-    const swaWorkflow = `name: Deploy Static Web App
+    const commonSetup = `      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+${pnpmSetupStep ? `\n${pnpmSetupStep}\n` : ''}
+      - name: Install dependencies
+        run: |
+          ${pmCmd.ci}
+      
+      - name: Build shared package
+        run: |
+          ${pmCmd.runFilter('shared')} build
+`;
+    if (backendLanguage === 'typescript') {
+        return `name: Deploy Azure Functions
 
 on:
   push:
     branches:
       - main
     paths:
-      - 'app/**'
-      - 'components/**'
-      - 'lib/**'
+      - 'functions/**'
       - 'shared/**'
-      - 'public/**'
-      - 'package.json'
-      - 'next.config.js'
-      - 'next.config.ts'
-  workflow_dispatch:
   pull_request:
     branches:
       - main
     paths:
-      - 'app/**'
-      - 'components/**'
-      - 'lib/**'
+      - 'functions/**'
       - 'shared/**'
-      - 'public/**'
-      - 'package.json'
-      - 'next.config.js'
-      - 'next.config.ts'
+  workflow_dispatch:
 
 jobs:
   build-and-deploy:
     runs-on: ubuntu-latest
-    name: Build and Deploy Static Web App
+    name: Build and Deploy Functions
     
     steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
+${commonSetup}      - name: Build Functions
+        run: |
+          ${pmCmd.runFilter('functions')} build
       
-      - name: Deploy to Azure Static Web Apps
+      - name: Prepare functions for deployment
+        run: |
+          SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
+          mkdir -p /tmp/fn-deps
+          node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
+          cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
+          rm -rf ./functions/node_modules
+          mv /tmp/fn-deps/node_modules ./functions/node_modules
+          SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
+          mkdir -p "$SHARED_DEST"
+          cp -r ./shared/dist "$SHARED_DEST/dist"
+          cp ./shared/package.json "$SHARED_DEST/package.json"
+      
+      - name: Deploy to Azure Functions
         if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
-        uses: Azure/static-web-apps-deploy@v1
+        uses: Azure/functions-action@v1
         with:
-          azure_static_web_apps_api_token: \${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
-          repo_token: \${{ secrets.GITHUB_TOKEN }}
-          action: 'upload'
-          app_location: '/'
-          api_location: ''
-          output_location: ''
-        env:
-          NEXT_TURBOPACK_EXPERIMENTAL_USE_SYSTEM_TLS_CERTS: '1'
+          app-name: \${{ secrets.AZURE_FUNCTIONAPP_NAME }}
+          package: './functions'
+          publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
+          sku: flexconsumption
 `;
-    fs.writeFileSync(path.join(workflowsDir, 'deploy-swa.yml'), swaWorkflow);
-    // deploy-functions.yml
-    const functionsWorkflow = `name: Deploy Azure Functions
+    }
+    if (backendLanguage === 'csharp') {
+        return `name: Deploy Azure Functions
 
 on:
   push:
@@ -2493,119 +2735,86 @@ jobs:
     name: Build and Deploy Functions
     
     steps:
-      - uses: actions/checkout@v4
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+${commonSetup}      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
         with:
-          node-version: '22'
-${pnpmSetupStep ? `\n${pnpmSetupStep}\n` : ''}
-      - name: Install dependencies
-        run: |
-          ${pmCmd.ci}
-      
-      - name: Build shared package
-        run: |
-          ${pmCmd.runFilter('shared')} build
-      
-      - name: Build Functions
-        run: |
-          ${pmCmd.runFilter('functions')} build
-      
-      - name: Prepare functions for deployment
+          dotnet-version: '8.0.x'
+
+      - name: Publish Functions
         run: |
-          SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
-          mkdir -p /tmp/fn-deps
-          node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
-          cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
-          rm -rf ./functions/node_modules
-          mv /tmp/fn-deps/node_modules ./functions/node_modules
-          SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
-          mkdir -p "$SHARED_DEST"
-          cp -r ./shared/dist "$SHARED_DEST/dist"
-          cp ./shared/package.json "$SHARED_DEST/package.json"
+          dotnet publish ./functions -c Release -o ./functions/publish
       
       - name: Deploy to Azure Functions
         if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
         uses: Azure/functions-action@v1
         with:
           app-name: \${{ secrets.AZURE_FUNCTIONAPP_NAME }}
-          package: './functions'
+          package: './functions/publish'
           publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
           sku: flexconsumption
 `;
-    fs.writeFileSync(path.join(workflowsDir, 'deploy-functions.yml'), functionsWorkflow);
-    console.log('✅ GitHub Actions workflows created\n');
-}
-async function createAzurePipelines(projectDir, pm) {
-    console.log('📦 Creating Azure Pipelines...\n');
-    const pmCmd = (0, package_manager_1.getCommands)(pm);
-    const azPipelinesSetup = (0, package_manager_1.getAzurePipelinesSetup)(pm);
-    const pipelinesDir = path.join(projectDir, 'pipelines');
-    fs.mkdirSync(pipelinesDir, { recursive: true });
-    // swa.yml
-    const swaPipeline = `trigger:
-  branches:
-    include:
-      - main
-  paths:
-    include:
-      - app/**
-      - components/**
-      - lib/**
-      - shared/**
-      - public/**
-      - package.json
-      - next.config.js
+    }
+    return `name: Deploy Azure Functions
 
-pr:
-  branches:
-    include:
+on:
+  push:
+    branches:
       - main
-  paths:
-    include:
-      - app/**
-      - components/**
-      - lib/**
-      - shared/**
-      - public/**
-      - package.json
-      - next.config.js
-
-pool:
-  vmImage: 'ubuntu-latest'
+    paths:
+      - 'functions/**'
+      - 'shared/**'
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'functions/**'
+      - 'shared/**'
+  workflow_dispatch:
 
-variables:
-  - group: azure-deployment
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Functions
+    
+    steps:
+${commonSetup}      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
 
-steps:
-  - task: NodeTool@0
+      - name: Install Functions dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r ./functions/requirements.txt --target "./functions/.python_packages/lib/site-packages"
+      
+      - name: Deploy to Azure Functions
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
+        uses: Azure/functions-action@v1
+        with:
+          app-name: \${{ secrets.AZURE_FUNCTIONAPP_NAME }}
+          package: './functions'
+          publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
+          sku: flexconsumption
+`;
+}
+function getAzureFunctionsPipeline(pm, backendLanguage) {
+    const pmCmd = (0, package_manager_1.getCommands)(pm);
+    const azPipelinesSetup = (0, package_manager_1.getAzurePipelinesSetup)(pm);
+    const commonSetup = `  - task: NodeTool@0
     inputs:
       versionSpec: '22.x'
     displayName: 'Install Node.js'
 ${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
   - script: |
       ${pmCmd.ci}
-    displayName: 'Install dependencies'
+    displayName: 'Install workspace dependencies'
 
   - script: |
-      ${pmCmd.run} build
-    env:
-      NODE_ENV: production
-    displayName: 'Build Next.js app'
-
-  - task: AzureStaticWebApp@0
-    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
-    inputs:
-      app_location: '.'
-      output_location: '.next/standalone'
-      skip_app_build: true
-      azure_static_web_apps_api_token: $(AZURE_STATIC_WEB_APPS_API_TOKEN)
-    displayName: 'Deploy to Azure Static Web Apps'
+      ${pmCmd.runFilter('shared')} build
+    displayName: 'Build shared package'
 `;
-    fs.writeFileSync(path.join(pipelinesDir, 'swa.yml'), swaPipeline);
-    // functions.yml
-    const functionsPipeline = `trigger:
+    if (backendLanguage === 'typescript') {
+        return `trigger:
   branches:
     include:
       - main
@@ -2630,20 +2839,7 @@ variables:
   - group: azure-deployment
 
 steps:
-  - task: NodeTool@0
-    inputs:
-      versionSpec: '22.x'
-    displayName: 'Install Node.js'
-${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
-  - script: |
-      ${pmCmd.ci}
-    displayName: 'Install workspace dependencies'
-
-  - script: |
-      ${pmCmd.runFilter('shared')} build
-    displayName: 'Build shared package'
-
-  - script: |
+${commonSetup}  - script: |
       ${pmCmd.runFilter('functions')} build
     displayName: 'Build Functions'
 
@@ -2685,6 +2881,248 @@ ${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
       package: '$(Build.ArtifactStagingDirectory)/functions.zip'
     displayName: 'Deploy to Azure Functions'
 `;
+    }
+    if (backendLanguage === 'csharp') {
+        return `trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pr:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: azure-deployment
+
+steps:
+${commonSetup}  - task: UseDotNet@2
+    inputs:
+      version: '8.0.x'
+    displayName: 'Install .NET SDK'
+
+  - script: |
+      dotnet publish ./functions -c Release -o ./functions/publish
+    displayName: 'Publish Functions'
+
+  - task: ArchiveFiles@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)/functions/publish'
+      includeRootFolder: false
+      archiveType: 'zip'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Archive Functions'
+
+  - task: AzureFunctionApp@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      azureSubscription: '$(AZURE_SUBSCRIPTION)'
+      appType: 'functionAppLinux'
+      appName: '$(AZURE_FUNCTIONAPP_NAME)'
+      package: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Deploy to Azure Functions'
+`;
+    }
+    return `trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pr:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: azure-deployment
+
+steps:
+${commonSetup}  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '3.11'
+    displayName: 'Install Python'
+
+  - script: |
+      python -m pip install --upgrade pip
+      python -m pip install -r ./functions/requirements.txt --target "./functions/.python_packages/lib/site-packages"
+    displayName: 'Install Functions dependencies'
+
+  - task: ArchiveFiles@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)/functions'
+      includeRootFolder: false
+      archiveType: 'zip'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Archive Functions'
+
+  - task: AzureFunctionApp@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      azureSubscription: '$(AZURE_SUBSCRIPTION)'
+      appType: 'functionAppLinux'
+      appName: '$(AZURE_FUNCTIONAPP_NAME)'
+      package: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Deploy to Azure Functions'
+`;
+}
+async function createGitHubActionsWorkflows(projectDir, azureConfig, pm, backendLanguage) {
+    console.log('📦 Creating GitHub Actions workflows...\n');
+    const pmCmd = (0, package_manager_1.getCommands)(pm);
+    const workflowsDir = path.join(projectDir, '.github', 'workflows');
+    fs.mkdirSync(workflowsDir, { recursive: true });
+    // deploy-swa.yml
+    const swaWorkflow = `name: Deploy Static Web App
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'app/**'
+      - 'components/**'
+      - 'lib/**'
+      - 'shared/**'
+      - 'public/**'
+      - 'package.json'
+      - 'next.config.js'
+      - 'next.config.ts'
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'app/**'
+      - 'components/**'
+      - 'lib/**'
+      - 'shared/**'
+      - 'public/**'
+      - 'package.json'
+      - 'next.config.js'
+      - 'next.config.ts'
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Static Web App
+    
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      
+      - name: Deploy to Azure Static Web Apps
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: \${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
+          repo_token: \${{ secrets.GITHUB_TOKEN }}
+          action: 'upload'
+          app_location: '/'
+          api_location: ''
+          output_location: ''
+        env:
+          NEXT_TURBOPACK_EXPERIMENTAL_USE_SYSTEM_TLS_CERTS: '1'
+`;
+    fs.writeFileSync(path.join(workflowsDir, 'deploy-swa.yml'), swaWorkflow);
+    // deploy-functions.yml
+    const functionsWorkflow = getGitHubFunctionsWorkflow(pm, backendLanguage);
+    fs.writeFileSync(path.join(workflowsDir, 'deploy-functions.yml'), functionsWorkflow);
+    console.log('✅ GitHub Actions workflows created\n');
+}
+async function createAzurePipelines(projectDir, pm, backendLanguage) {
+    console.log('📦 Creating Azure Pipelines...\n');
+    const pmCmd = (0, package_manager_1.getCommands)(pm);
+    const azPipelinesSetup = (0, package_manager_1.getAzurePipelinesSetup)(pm);
+    const pipelinesDir = path.join(projectDir, 'pipelines');
+    fs.mkdirSync(pipelinesDir, { recursive: true });
+    // swa.yml
+    const swaPipeline = `trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - app/**
+      - components/**
+      - lib/**
+      - shared/**
+      - public/**
+      - package.json
+      - next.config.js
+
+pr:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - app/**
+      - components/**
+      - lib/**
+      - shared/**
+      - public/**
+      - package.json
+      - next.config.js
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: azure-deployment
+
+steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '22.x'
+    displayName: 'Install Node.js'
+${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
+  - script: |
+      ${pmCmd.ci}
+    displayName: 'Install dependencies'
+
+  - script: |
+      ${pmCmd.run} build
+    env:
+      NODE_ENV: production
+    displayName: 'Build Next.js app'
+
+  - task: AzureStaticWebApp@0
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      app_location: '.'
+      output_location: '.next/standalone'
+      skip_app_build: true
+      azure_static_web_apps_api_token: $(AZURE_STATIC_WEB_APPS_API_TOKEN)
+    displayName: 'Deploy to Azure Static Web Apps'
+`;
+    fs.writeFileSync(path.join(pipelinesDir, 'swa.yml'), swaPipeline);
+    // functions.yml
+    const functionsPipeline = getAzureFunctionsPipeline(pm, backendLanguage);
     fs.writeFileSync(path.join(pipelinesDir, 'functions.yml'), functionsPipeline);
     console.log('✅ Azure Pipelines created\n');
 }