swallowkit 1.0.0-beta.34 → 1.0.0-beta.37

package/src/__tests__/machine.test.ts

@@ -1,8 +1,19 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { EventEmitter } from "events";
+import * as childProcess from "child_process";
 import { runMachineCli } from "../machine";
 
+jest.mock("child_process", () => {
+  const actual = jest.requireActual<typeof import("child_process")>("child_process");
+  return {
+    ...actual,
+    spawn: jest.fn(),
+    spawnSync: jest.fn(),
+  };
+});
+
 const repoRoot = process.cwd();
 
 function writeFile(filePath: string, content: string): void {
@@ -68,6 +79,59 @@ function createProjectFixture(rootDir: string, options: { includeGeneratedArtifa
   }
 }
 
+function createCSharpScaffoldFixture(rootDir: string): void {
+  writeFile(path.join(rootDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
+  writeFile(
+    path.join(rootDir, "swallowkit.config.js"),
+    `module.exports = {
+  backend: {
+    language: 'csharp',
+  },
+  api: {
+    endpoint: '/api/_swallowkit',
+  },
+};
+`
+  );
+  writeFile(path.join(rootDir, "shared", "package.json"), JSON.stringify({ name: "@sample-app/shared" }, null, 2));
+  writeFile(path.join(rootDir, "shared", "index.ts"), "export {};\n");
+  writeFile(path.join(rootDir, "shared", "models", "estimate.ts"), createModelSource("Estimate"));
+  writeFile(path.join(rootDir, "shared", "models", "member.ts"), createModelSource("Member"));
+  writeFile(path.join(rootDir, "shared", "models", "team.ts"), createModelSource("Team"));
+  fs.mkdirSync(path.join(rootDir, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules", "zod"),
+    path.join(rootDir, "node_modules", "zod"),
+    "junction"
+  );
+
+  writeFile(
+    path.join(rootDir, "functions", "Crud", "EstimateFunctions.cs"),
+    "namespace SwallowKit.Functions;\npublic sealed class EstimateFunctions { public void Approve() {} public void Submit() {} public void Remand() {} }\n"
+  );
+  writeFile(path.join(rootDir, "functions", "generated", "csharp-models", "README.md"), "keep generated readme\n");
+  writeFile(path.join(rootDir, "functions", "generated", "csharp-models", "SwallowKitBackendModels.csproj"), "<Project />\n");
+  writeFile(path.join(rootDir, "functions", "generated", "csharp-models", "SwallowKitBackendModels.sln"), "solution\n");
+  writeFile(
+    path.join(rootDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "Member.cs"),
+    "// existing member\n"
+  );
+  writeFile(
+    path.join(rootDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "Team.cs"),
+    "// existing team\n"
+  );
+}
+
+function mockSuccessfulSpawn() {
+  const spawnMock = childProcess.spawn as unknown as any;
+  spawnMock.mockImplementation(() => {
+    const child = new EventEmitter() as childProcess.ChildProcess;
+    process.nextTick(() => child.emit("close", 0));
+    return child;
+  });
+  return spawnMock;
+}
+
 function createFreshInitProjectFixture(rootDir: string, backendLanguage: "csharp" | "python" = "csharp"): void {
   writeFile(path.join(rootDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
   writeFile(
@@ -248,4 +312,45 @@ describe("machine CLI", () => {
     );
     expect(fs.existsSync(path.join(tempDir, ".swallowkit", "project.json"))).toBe(true);
   });
+
+  it("preserves C# custom Functions and shared generated assets when api-only scaffolding one model", async () => {
+    createCSharpScaffoldFixture(tempDir);
+    const spawnSyncMock = childProcess.spawnSync as unknown as any;
+    spawnSyncMock.mockReturnValue({ status: 0 });
+    const spawnMock = mockSuccessfulSpawn();
+
+    try {
+      const { response, exitCode } = await runMachine([
+        "node",
+        "swallowkit",
+        "machine",
+        "generate",
+        "scaffold",
+        "estimate",
+        "--api-only",
+      ]);
+
+      expect(exitCode).toBe(0);
+      expect(response.ok).toBe(true);
+      expect(response.command).toBe("generate-scaffold");
+      expect(response.data.createdFiles).toEqual(
+        expect.arrayContaining([
+          "functions/Crud/EstimateCrudFunctions.cs",
+          "app/api/estimate/route.ts",
+          "app/api/estimate/[id]/route.ts",
+        ])
+      );
+      expect(response.data.deletedFiles).toEqual([]);
+      expect(fs.readFileSync(path.join(tempDir, "functions", "Crud", "EstimateFunctions.cs"), "utf-8")).toContain("Approve");
+      expect(fs.existsSync(path.join(tempDir, "functions", "generated", "csharp-models", "README.md"))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, "functions", "generated", "csharp-models", "SwallowKitBackendModels.csproj"))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, "functions", "generated", "csharp-models", "SwallowKitBackendModels.sln"))).toBe(true);
+      expect(fs.readFileSync(path.join(tempDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "Member.cs"), "utf-8")).toBe("// existing member\n");
+      expect(fs.readFileSync(path.join(tempDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "Team.cs"), "utf-8")).toBe("// existing team\n");
+      expect(fs.existsSync(path.join(tempDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "Estimate.cs"))).toBe(true);
+    } finally {
+      spawnMock.mockReset();
+      spawnSyncMock.mockReset();
+    }
+  });
 });

package/src/__tests__/scaffold.test.ts

@@ -1,14 +1,44 @@
 import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { EventEmitter } from "events";
+import * as childProcess from "child_process";
 import {
   NSWAG_CONSOLECORE_VERSION,
   buildCSharpCodegenToolManifestSource,
   buildPythonCodegenRequirementsSource,
+  generateLanguageSchemaArtifacts,
   getCSharpNativeGeneratorArgs,
   getCSharpSchemaModelPath,
   getCSharpSchemaOptionPath,
   getPythonNativeGeneratorArgs,
   getPythonSchemaModelPath,
 } from "../core/scaffold/native-schema-generator";
+import { createBasicModelInfo } from "./fixtures";
+
+jest.mock("child_process", () => {
+  const actual = jest.requireActual<typeof import("child_process")>("child_process");
+  return {
+    ...actual,
+    spawn: jest.fn(),
+    spawnSync: jest.fn(),
+  };
+});
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+function mockSuccessfulSpawn() {
+  const spawnMock = childProcess.spawn as unknown as any;
+  spawnMock.mockImplementation(() => {
+    const child = new EventEmitter() as childProcess.ChildProcess;
+    process.nextTick(() => child.emit("close", 0));
+    return child;
+  });
+  return spawnMock;
+}
 
 describe("native schema generators", () => {
   it("writes a dotnet tool manifest for NSwag", () => {
@@ -64,4 +94,68 @@ describe("native schema generators", () => {
       path.join("C:\\temp\\generated\\python-models", "backend_models", "models", "product.py")
     );
   });
+
+  describe("non-destructive native schema generation", () => {
+    const originalCwd = process.cwd();
+    let tempDir: string;
+    let spawnSyncMock: any;
+    let spawnMock: any;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-native-schema-"));
+      process.chdir(tempDir);
+      fs.mkdirSync(path.join(tempDir, "functions"), { recursive: true });
+      spawnSyncMock = childProcess.spawnSync as unknown as any;
+      spawnSyncMock.mockReturnValue({ status: 0 });
+      spawnMock = mockSuccessfulSpawn();
+    });
+
+    afterEach(() => {
+      spawnMock.mockReset();
+      spawnSyncMock.mockReset();
+      process.chdir(originalCwd);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("preserves existing C# generated directory contents while writing only requested model files", async () => {
+      const outputDir = path.join(tempDir, "functions", "generated", "csharp-models");
+      writeFile(path.join(outputDir, "README.md"), "keep me\n");
+      writeFile(path.join(outputDir, "SwallowKitBackendModels.csproj"), "<Project />\n");
+      writeFile(path.join(outputDir, "src", "SwallowKitBackendModels", "Model", "Member.cs"), "// existing member\n");
+
+      const estimate = createBasicModelInfo({ name: "Estimate", filePath: path.join(tempDir, "shared", "models", "estimate.ts") });
+
+      await generateLanguageSchemaArtifacts([estimate], estimate, "functions", "csharp");
+
+      expect(fs.readFileSync(path.join(outputDir, "README.md"), "utf-8")).toBe("keep me\n");
+      expect(fs.existsSync(path.join(outputDir, "SwallowKitBackendModels.csproj"))).toBe(true);
+      expect(fs.readFileSync(getCSharpSchemaModelPath(outputDir, "Member"), "utf-8")).toBe("// existing member\n");
+      expect(fs.existsSync(getCSharpSchemaModelPath(outputDir, "Todo"))).toBe(false);
+      expect(fs.existsSync(getCSharpSchemaModelPath(outputDir, "Estimate"))).toBe(true);
+      expect(fs.existsSync(getCSharpSchemaOptionPath(outputDir))).toBe(true);
+    });
+
+    it("preserves existing Python generated directory contents while appending requested model exports", async () => {
+      const outputDir = path.join(tempDir, "functions", "generated", "python-models");
+      writeFile(path.join(outputDir, "README.md"), "keep python\n");
+      writeFile(path.join(outputDir, "backend_models", "models", "member.py"), "# existing member\n");
+      writeFile(path.join(outputDir, "backend_models", "__init__.py"), "from .models.member import Member\n");
+      writeFile(path.join(outputDir, "backend_models", "models", "__init__.py"), "from .member import Member\n");
+
+      const estimate = createBasicModelInfo({ name: "Estimate", filePath: path.join(tempDir, "shared", "models", "estimate.ts") });
+
+      await generateLanguageSchemaArtifacts([estimate], estimate, "functions", "python");
+
+      expect(fs.readFileSync(path.join(outputDir, "README.md"), "utf-8")).toBe("keep python\n");
+      expect(fs.readFileSync(path.join(outputDir, "backend_models", "models", "member.py"), "utf-8")).toBe("# existing member\n");
+      expect(fs.existsSync(getPythonSchemaModelPath(outputDir, "Todo"))).toBe(false);
+      expect(fs.existsSync(getPythonSchemaModelPath(outputDir, "Estimate"))).toBe(true);
+      const packageInit = fs.readFileSync(path.join(outputDir, "backend_models", "__init__.py"), "utf-8");
+      const modelsInit = fs.readFileSync(path.join(outputDir, "backend_models", "models", "__init__.py"), "utf-8");
+      expect(packageInit).toContain("from .models.member import Member");
+      expect(packageInit).toContain("from .models.estimate import Estimate");
+      expect(modelsInit).toContain("from .member import Member");
+      expect(modelsInit).toContain("from .estimate import Estimate");
+    });
+  });
 });

package/src/cli/commands/init.ts

@@ -375,32 +375,136 @@ async function upgradeNextJs(projectDir: string, version: string, pm: PackageMan
 }
 
 async function installDependencies(projectDir: string, pm: PackageManager = 'pnpm'): Promise<void> {
+  console.log('\n📦 Installing dependencies...\n');
+
+  const { ignoredBuilds } = await runInstallAndDetectIgnoredBuilds(projectDir, pm);
+
+  console.log('\n✅ Dependencies installed\n');
+
+  if (pm === 'pnpm' && ignoredBuilds.length > 0) {
+    await maybeApproveBuilds(projectDir, ignoredBuilds);
+  }
+}
+
+/**
+ * Run `<pm> install` while passing through stdio so the user sees progress.
+ * For pnpm, also tee stdout/stderr to detect the ERR_PNPM_IGNORED_BUILDS warning
+ * and extract the affected package names.
+ */
+async function runInstallAndDetectIgnoredBuilds(
+  projectDir: string,
+  pm: PackageManager,
+): Promise<{ ignoredBuilds: string[] }> {
   return new Promise((resolve, reject) => {
-    console.log('\n📦 Installing dependencies...\n');
-    
-    const child = spawn(
-      pm,
-      ['install'],
-      {
+    // For npm, we don't need to detect anything — keep simple inherit behavior.
+    if (pm !== 'pnpm') {
+      const child = spawn(pm, ['install'], {
         cwd: projectDir,
         stdio: 'inherit',
         shell: true,
-      }
-    );
+      });
+      child.on('close', (code) => {
+        if (code !== 0) reject(new Error(`${pm} install exited with code ${code}`));
+        else resolve({ ignoredBuilds: [] });
+      });
+      child.on('error', reject);
+      return;
+    }
 
-    child.on('close', (code: number | null) => {
+    // pnpm: capture output while teeing to the user's terminal.
+    const child = spawn(pm, ['install'], {
+      cwd: projectDir,
+      stdio: ['inherit', 'pipe', 'pipe'],
+      shell: true,
+    });
+
+    let combined = '';
+    child.stdout?.on('data', (chunk: Buffer) => {
+      process.stdout.write(chunk);
+      combined += chunk.toString('utf8');
+    });
+    child.stderr?.on('data', (chunk: Buffer) => {
+      process.stderr.write(chunk);
+      combined += chunk.toString('utf8');
+    });
+
+    child.on('close', (code) => {
       if (code !== 0) {
         reject(new Error(`${pm} install exited with code ${code}`));
-      } else {
-        console.log('\n✅ Dependencies installed\n');
-        resolve();
+        return;
       }
+      resolve({ ignoredBuilds: parseIgnoredBuilds(combined) });
     });
+    child.on('error', reject);
+  });
+}
 
-    child.on('error', (error: Error) => {
-      reject(error);
+/**
+ * Parse pnpm's `Ignored build scripts: foo@1.0.0, bar@2.0.0` warning and return
+ * the bare package names (without versions), de-duplicated.
+ *
+ * Matches both `ERR_PNPM_IGNORED_BUILDS` and the plain `Ignored build scripts:` line.
+ */
+export function parseIgnoredBuilds(output: string): string[] {
+  const match = output.match(/Ignored build scripts:\s*([^\n\r]+)/i);
+  if (!match) return [];
+  const list = match[1]
+    .split(',')
+    .map((entry) => entry.trim())
+    // strip version suffix: `sharp@0.34.5` -> `sharp`, `@scope/pkg@1.0.0` -> `@scope/pkg`
+    .map((entry) => entry.replace(/@[^@]+$/, ''))
+    .filter((name) => name.length > 0);
+  return Array.from(new Set(list));
+}
+
+async function maybeApproveBuilds(projectDir: string, ignoredBuilds: string[]): Promise<void> {
+  console.log(
+    `\n⚠️  pnpm skipped build scripts for: ${ignoredBuilds.join(', ')}\n` +
+      '   These packages (e.g. sharp) need their build scripts to run correctly.\n',
+  );
+
+  const response = await prompts({
+    type: 'confirm',
+    name: 'approve',
+    message: 'Run `pnpm approve-builds` now to approve these build scripts?',
+    initial: true,
+  });
+
+  if (!response.approve) {
+    console.log(
+      '\nℹ️  Skipped. You can run `pnpm approve-builds` later inside the project directory.\n',
+    );
+    return;
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn('pnpm', ['approve-builds'], {
+      cwd: projectDir,
+      stdio: 'inherit',
+      shell: true,
+    });
+    child.on('close', (code) => {
+      if (code !== 0) reject(new Error(`pnpm approve-builds exited with code ${code}`));
+      else resolve();
     });
+    child.on('error', reject);
   });
+
+  // After approval, rebuild the approved packages so their native binaries are present.
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn('pnpm', ['rebuild', ...ignoredBuilds], {
+      cwd: projectDir,
+      stdio: 'inherit',
+      shell: true,
+    });
+    child.on('close', (code) => {
+      if (code !== 0) reject(new Error(`pnpm rebuild exited with code ${code}`));
+      else resolve();
+    });
+    child.on('error', reject);
+  });
+
+  console.log('\n✅ Build scripts approved and packages rebuilt\n');
 }
 
 export function injectSwallowKitNextConfig(nextConfigContent: string, projectName: string): string {
@@ -876,7 +980,7 @@ export async function register() {
   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, backendLanguage);
+  createAiAgentFiles(projectDir, projectName, backendLanguage, pm);
 }
 
 async function createSharedPackage(projectDir: string, projectName: string) {
@@ -1700,9 +1804,10 @@ This project was generated by SwallowKit. If you encounter any issues or have su
   console.log('✅ README.md created\n');
 }
 
-function createAiAgentFiles(projectDir: string, projectName: string, backendLanguage: BackendLanguage) {
+function createAiAgentFiles(projectDir: string, projectName: string, backendLanguage: BackendLanguage, pm: PackageManager) {
   console.log('🤖 Creating AI agent instruction files...\n');
   const backendLanguageLabel = getBackendLanguageLabel(backendLanguage);
+  const runCmd = pm === 'pnpm' ? 'pnpm' : 'npx';
   const projectMcpConfigSource = buildSwallowKitMcpProjectConfigSource();
   const functionsStructureLine = backendLanguage === 'typescript'
     ? `│   └── src/               # HTTP trigger handlers with Cosmos DB bindings`
@@ -1764,11 +1869,12 @@ ${functionsStructureLine}
 - This repository includes a project-scoped \`.mcp.json\` file that starts the locally installed SwallowKit MCP server on runtimes that auto-load project MCP configurations.
 - Prefer the \`swallowkit_*\` MCP tools for framework-owned inspection, validation, and generation when they are available.
 - If MCP is unavailable in your runtime, fall back to the machine CLI:
-  - \`npx swallowkit machine inspect project\`
-  - \`npx swallowkit machine validate project\`
-  - \`npx swallowkit machine generate scaffold <name> --api-only\`
+  - \`${runCmd} swallowkit machine inspect project\`
+  - \`${runCmd} swallowkit machine validate project\`
+  - \`${runCmd} swallowkit machine generate scaffold <name> --api-only\`
 - Do not hand-edit framework-owned artifacts when the MCP or machine interface can generate or validate them for you.
 - The local MCP bootstrap depends on project dependencies already being installed.
+- **Always invoke SwallowKit via \`${runCmd}\`.** Do not mix package manager commands.
 
 ## Critical Design Principles
 
@@ -1869,7 +1975,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 | backend-language specific under \`functions/\` | \`${backendLanguage === 'typescript' ? 'functions/src/todo.ts' : backendLanguage === 'csharp' ? 'functions/Crud/TodoFunctions.cs' : 'functions/blueprints/todo.py'}\` |
+| Functions handler file | backend-language specific under \`functions/\` | \`${backendLanguage === 'typescript' ? 'functions/src/todo.ts' : backendLanguage === 'csharp' ? 'functions/Crud/TodoCrudFunctions.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\` |
@@ -1887,9 +1993,9 @@ Use the SwallowKit CLI — do **not** manually create model files or CRUD boiler
 ### Skill: Create a new data model
 
 \`\`\`bash
-npx swallowkit create-model <name>
+${runCmd} swallowkit create-model <name>
 # Multiple models at once:
-npx swallowkit create-model user post comment
+${runCmd} swallowkit create-model user post comment
 \`\`\`
 
 Creates \`shared/models/<name>.ts\` with a Zod schema template including \`id\`, \`createdAt\`, \`updatedAt\`.
@@ -1898,7 +2004,7 @@ Edit the generated file to add your domain-specific fields, then run scaffold.
 ### Skill: Generate full CRUD from a model
 
 \`\`\`bash
-npx swallowkit scaffold shared/models/<name>.ts
+${runCmd} swallowkit scaffold shared/models/<name>.ts
 \`\`\`
 
 Generates:
@@ -1910,7 +2016,7 @@ Generates:
 ### Skill: Start development servers
 
 \`\`\`bash
-npx swallowkit dev
+${runCmd} swallowkit dev
 \`\`\`
 
 Runs Next.js (http://localhost:3000) and Azure Functions (http://localhost:7071) concurrently.
@@ -1919,17 +2025,18 @@ Checks for Cosmos DB Emulator availability.
 ### Skill: Provision Azure resources
 
 \`\`\`bash
-npx swallowkit provision --resource-group <name> --location <region>
+${runCmd} swallowkit provision --resource-group <name> --location <region>
 \`\`\`
 
 Deploys Bicep infrastructure: Static Web Apps, Functions, Cosmos DB, Storage, Managed Identity.
 
 ### Typical workflow for "add a new feature/model"
 
-1. \`npx swallowkit create-model <name>\`
+1. \`${runCmd} swallowkit create-model <name>\`
 2. Edit \`shared/models/<name>.ts\` — add fields
-3. \`npx swallowkit scaffold shared/models/<name>.ts\`
-4. \`npx swallowkit dev\` — verify at http://localhost:3000/<name>
+3. \`${runCmd} swallowkit scaffold shared/models/<name>.ts\`
+4. \`${runCmd} swallowkit dev\` — verify at http://localhost:3000/<name>
+5. If \`dev-seeds/\` already exists, update the seed JSON files to include realistic data for the new model and adjust existing seeds if relationships changed.
 
 ## Do NOT
 
@@ -1974,23 +2081,25 @@ This file is for Claude Code. Read AGENTS.md in the project root for the full ar
 
 - This repository includes a project-scoped \`.mcp.json\` that registers the locally installed SwallowKit MCP server for runtimes that support project MCP files.
 - When the \`swallowkit_*\` tools are available, prefer them for inspect / validate / generate tasks.
-- If MCP is unavailable, use \`npx swallowkit machine ...\` instead.
+- If MCP is unavailable, use \`${runCmd} swallowkit machine ...\` instead.
+- **Always invoke SwallowKit via \`${runCmd}\`.** Do not mix package manager commands.
 
 ## SwallowKit CLI Commands
 
 | Task | Command |
 |------|---------|
-| Create model | \`npx swallowkit create-model <name>\` |
-| Generate CRUD | \`npx swallowkit scaffold shared/models/<name>.ts\` |
-| Dev servers | \`npx swallowkit dev\` |
-| Provision Azure | \`npx swallowkit provision --resource-group <rg> --location <region>\` |
+| Create model | \`${runCmd} swallowkit create-model <name>\` |
+| Generate CRUD | \`${runCmd} swallowkit scaffold shared/models/<name>.ts\` |
+| Dev servers | \`${runCmd} swallowkit dev\` |
+| Provision Azure | \`${runCmd} swallowkit provision --resource-group <rg> --location <region>\` |
 
 ## Workflow: Add a new model
 
-1. \`npx swallowkit create-model <name>\`
+1. \`${runCmd} swallowkit create-model <name>\`
 2. Edit \`shared/models/<name>.ts\` — add your fields
-3. \`npx swallowkit scaffold shared/models/<name>.ts\`
-4. \`npx swallowkit dev\` — verify at http://localhost:3000/<name>
+3. \`${runCmd} swallowkit scaffold shared/models/<name>.ts\`
+4. \`${runCmd} swallowkit dev\` — verify at http://localhost:3000/<name>
+5. If \`dev-seeds/\` exists, update the seed JSON files to include data for the new model and adjust existing seeds if relationships changed.
 `;
 
   fs.writeFileSync(path.join(projectDir, 'CLAUDE.md'), claudeMd);
@@ -2019,13 +2128,15 @@ 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 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.
+4. **Use the CLI** — Run \`${runCmd} swallowkit create-model <name>\` then \`${runCmd} swallowkit scaffold shared/models/<name>.ts\` to add models. Do not create boilerplate manually.
+5. **Maintain seed data** — When adding models or changing schemas, update the JSON files under \`dev-seeds/\` to keep seed data consistent with the current schema.
 
 ## SwallowKit Framework Operations
 
 - Prefer the SwallowKit MCP or machine interface for framework-owned inspection, validation, and generation instead of hand-editing generated files.
 - If your runtime loads project-scoped MCP config from \`.mcp.json\`, use the \`swallowkit_*\` tools.
-- Otherwise use \`npx swallowkit machine inspect project\`, \`npx swallowkit machine validate project\`, and \`npx swallowkit machine generate scaffold <name> --api-only\`.
+- Otherwise use \`${runCmd} swallowkit machine inspect project\`, \`${runCmd} swallowkit machine validate project\`, and \`${runCmd} swallowkit machine generate scaffold <name> --api-only\`.
+- **Always invoke SwallowKit via \`${runCmd}\`.** Do not mix package manager commands.
 
 ## Naming
 
@@ -2067,7 +2178,7 @@ Files in this directory are the **single source of truth** for data models acros
 - Export a \`displayName\` string constant for UI display.
 - Re-export every model from \`shared/index.ts\`.
 - For relationships, use **nested schemas** (import and embed the related schema), not ID references.
-- After editing a model, run \`npx swallowkit scaffold shared/models/<name>.ts\` to regenerate CRUD code.
+- After editing a model, run \`${runCmd} swallowkit scaffold shared/models/<name>.ts\` to regenerate CRUD code.
 `;
 
   fs.writeFileSync(

package/src/cli/commands/scaffold.ts

@@ -120,6 +120,10 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
       ? [modelInfo]
       : await collectModelGraph(modelPath);
 
+    if (options.apiOnly) {
+      console.log("ℹ️  --api-only skips UI generation only; Functions, BFF routes, OpenAPI, and native schema assets are still updated.");
+    }
+
     // 5. Generate BFF callFunction helper
     await generateCallFunctionHelper();
 
@@ -351,7 +355,7 @@ async function generateFunctionsCode(
 
   if (backendLanguage === "csharp") {
     const crudDir = path.join(process.cwd(), functionsDir, "Crud");
-    const functionFilePath = path.join(crudDir, `${modelInfo.name}Functions.cs`);
+    const functionFilePath = path.join(crudDir, `${modelInfo.name}CrudFunctions.cs`);
     fs.mkdirSync(crudDir, { recursive: true });
 
     // Remove init-generated template (singular) to avoid route conflicts

package/src/cli/index.ts

@@ -142,7 +142,7 @@ export function createProgram(devCommandOverride: Command = devCommand): Command
     .description("Generate CRUD code for Azure Functions and Next.js BFF from Zod models")
     .option("--functions-dir <dir>", "Azure Functions directory", "functions")
     .option("--api-dir <dir>", "Next.js API routes directory", "app/api")
-    .option("--api-only", "Generate API only, skip UI components", false)
+    .option("--api-only", "Skip UI components; still update Functions, BFF routes, OpenAPI, and native schema assets", false)
     .action((model, options) => {
       scaffoldCommand({
         model,

package/src/core/project/manifest.ts

@@ -198,7 +198,7 @@ function buildEntityRoutes(
     : backendLanguage === "csharp"
       ? isConnectorEntity
         ? `functions/Connectors/${entity.name}ConnectorFunctions.cs`
-        : `functions/Crud/${entity.name}Functions.cs`
+        : `functions/Crud/${entity.name}CrudFunctions.cs`
       : `functions/blueprints/${modelKebab.replace(/-/g, "_")}.py`;
 
   const operations = entity.connectorConfig?.operations ?? ["getAll", "getById", "create", "update", "delete"];

package/src/core/scaffold/functions-generator.ts

@@ -418,7 +418,7 @@ ${authCatchBlock}      context.error(\`Error deleting item from \${containerName
 export function generateCSharpAzureFunctionsCRUD(model: ModelInfo, authPolicy?: ModelAuthPolicy): string {
   const modelName = model.name;
   const modelCamel = toCamelCase(modelName);
-  const className = `${modelName}Functions`;
+  const className = `${modelName}CrudFunctions`;
   const containerName = modelName.endsWith('s') ? modelName : `${modelName}s`;
 
   const partitionKeyPath = model.partitionKey;

package/src/core/scaffold/native-schema-generator.ts

@@ -601,6 +601,31 @@ function buildGeneratedPythonModelsInitSource(models: ModelInfo[]): string {
   return models.map((model) => `from .${toSnakeCase(model.name)} import ${model.name}`).join("\n") + "\n";
 }
 
+function mergePythonInitSource(existingSource: string | undefined, generatedSource: string): string {
+  if (!existingSource) {
+    return generatedSource;
+  }
+
+  const existingLines = existingSource.split(/\r?\n/);
+  const lineSet = new Set(existingLines);
+  const missingLines = generatedSource
+    .trim()
+    .split(/\r?\n/)
+    .filter((line) => line.length > 0 && !lineSet.has(line));
+
+  if (missingLines.length === 0) {
+    return existingSource.endsWith("\n") ? existingSource : `${existingSource}\n`;
+  }
+
+  const normalizedExisting = existingSource.endsWith("\n") ? existingSource : `${existingSource}\n`;
+  return `${normalizedExisting}${missingLines.join("\n")}\n`;
+}
+
+function writeMergedPythonInitFile(filePath: string, generatedSource: string): void {
+  const existingSource = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : undefined;
+  fs.writeFileSync(filePath, mergePythonInitSource(existingSource, generatedSource), "utf-8");
+}
+
 function ensureCSharpCodegenProjectFiles(functionsRoot: string): void {
   const toolManifestPath = path.join(functionsRoot, ".config", "dotnet-tools.json");
   fs.mkdirSync(path.dirname(toolManifestPath), { recursive: true });
@@ -752,8 +777,8 @@ async function generatePythonSchemaArtifacts(
   const packageRoot = path.join(outputDir, "backend_models");
   const modelsRoot = path.join(packageRoot, "models");
   fs.mkdirSync(modelsRoot, { recursive: true });
-  fs.writeFileSync(path.join(packageRoot, "__init__.py"), buildGeneratedPythonPackageInitSource(models), "utf-8");
-  fs.writeFileSync(path.join(modelsRoot, "__init__.py"), buildGeneratedPythonModelsInitSource(models), "utf-8");
+  writeMergedPythonInitFile(path.join(packageRoot, "__init__.py"), buildGeneratedPythonPackageInitSource(models));
+  writeMergedPythonInitFile(path.join(modelsRoot, "__init__.py"), buildGeneratedPythonModelsInitSource(models));
 
   for (const model of models) {
     const modelPath = getPythonSchemaModelPath(outputDir, model.name);
@@ -785,7 +810,6 @@ export async function generateLanguageSchemaArtifacts(
     backendLanguage === "csharp" ? "csharp-models" : "python-models"
   );
 
-  fs.rmSync(outputDir, { recursive: true, force: true });
   fs.mkdirSync(outputDir, { recursive: true });
 
   if (backendLanguage === "csharp") {

package/src/machine/index.ts

@@ -134,7 +134,7 @@ function createMachineProgram(): Command {
     .argument("<model>", "Model file or model name")
     .option("--functions-dir <dir>", "Functions directory", "functions")
     .option("--api-dir <dir>", "API routes directory", "app/api")
-    .option("--api-only", "Generate only API artifacts", false)
+    .option("--api-only", "Skip UI components; still update Functions, BFF routes, OpenAPI, and native schema assets", false)
     .action(async (model: string, options: { functionsDir?: string; apiDir?: string; apiOnly?: boolean }) => {
       await handleMachineAction("generate-scaffold", async () => runMachineScaffoldOperation({
         model,