aerocoding 0.1.23 → 0.1.24

package/dist/index.js

@@ -81,7 +81,7 @@ var DeviceFlow = class {
    * Step 3: Poll for token
    */
   async pollForToken(auth) {
-    const spinner2 = ora({
+    const spinner5 = ora({
       text: "Waiting for authorization...",
       color: "cyan"
     }).start();
@@ -89,7 +89,7 @@ var DeviceFlow = class {
     let currentInterval = auth.interval * 1e3;
     while (true) {
       if (Date.now() - startTime > MAX_POLL_TIME) {
-        spinner2.fail(chalk.red("Authorization timeout"));
+        spinner5.fail(chalk.red("Authorization timeout"));
         throw new Error("Device authorization timed out");
       }
       try {
@@ -97,7 +97,7 @@ var DeviceFlow = class {
           device_code: auth.device_code,
           client_id: "aerocoding-cli"
         });
-        spinner2.succeed(chalk.green("Successfully authenticated!"));
+        spinner5.succeed(chalk.green("Successfully authenticated!"));
         return response.data;
       } catch (error) {
         const errorCode = error.response?.data?.error;
@@ -108,19 +108,19 @@ var DeviceFlow = class {
         }
         if (errorCode === "slow_down") {
           currentInterval += 5e3;
-          spinner2.text = "Polling... (slowed down to avoid spam)";
+          spinner5.text = "Polling... (slowed down to avoid spam)";
           await this.sleep(currentInterval);
           continue;
         }
         if (errorCode === "expired_token") {
-          spinner2.fail(chalk.red("Authorization code expired"));
+          spinner5.fail(chalk.red("Authorization code expired"));
           throw new Error("Device code expired. Please try again.");
         }
         if (errorCode === "access_denied") {
-          spinner2.fail(chalk.red("Authorization denied"));
+          spinner5.fail(chalk.red("Authorization denied"));
           throw new Error("You denied the authorization request");
         }
-        spinner2.fail(chalk.red("Authorization failed"));
+        spinner5.fail(chalk.red("Authorization failed"));
         console.error(
           chalk.red(`Error: ${errorDescription || "Unknown error"}`)
         );
@@ -132,7 +132,7 @@ var DeviceFlow = class {
    * Helper: Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 };
 
@@ -391,6 +391,34 @@ var ApiClient = class {
     const response = await this.client.get(`/api/templates/${templateId}?compatible=true`);
     return response.data.compatible || [];
   }
+  // ============================================
+  // Manifest Cloud Sync API
+  // ============================================
+  /**
+   * Get manifest from cloud storage
+   * @returns Manifest or null if not found
+   */
+  async getManifest(projectId) {
+    try {
+      const response = await this.client.get(`/api/projects/${projectId}/manifest`);
+      return response.data;
+    } catch (error) {
+      if (error?.response?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Save manifest to cloud storage
+   */
+  async saveManifest(projectId, manifest) {
+    const response = await this.client.put(
+      `/api/projects/${projectId}/manifest`,
+      manifest
+    );
+    return response.data;
+  }
 };
 
 // src/commands/_shared/create-api-client.ts
@@ -520,13 +548,266 @@ import ora2 from "ora";
 import * as p from "@clack/prompts";
 
 // src/utils/file-writer.ts
-import fs from "fs/promises";
-import path from "path";
+import fs3 from "fs/promises";
+import path2 from "path";
 import chalk6 from "chalk";
+
+// src/manifest/index.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+
+// src/manifest/types.ts
+var MANIFEST_VERSION = "1.0.0";
+var MANIFEST_FILENAME = "aerocoding-manifest.json";
+
+// src/manifest/hash-utils.ts
+import * as crypto from "crypto";
+import * as fs from "fs/promises";
+import { createReadStream } from "fs";
+function hashString(content) {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+async function hashFile(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve2(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+async function getFileStats(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return {
+      mtime: Math.floor(stats.mtimeMs),
+      size: stats.size
+    };
+  } catch {
+    return null;
+  }
+}
+function mightHaveChanged(currentStats, manifestEntry) {
+  return currentStats.mtime !== manifestEntry.mtime || currentStats.size !== manifestEntry.size;
+}
+async function detectFileChange(filePath, manifestEntry) {
+  const stats = await getFileStats(filePath);
+  if (!stats) {
+    if (manifestEntry) {
+      return { status: "deleted" };
+    }
+    return { status: "new" };
+  }
+  if (!manifestEntry) {
+    return { status: "unknown" };
+  }
+  if (!mightHaveChanged(stats, manifestEntry)) {
+    return { status: "unchanged" };
+  }
+  const currentHash = await hashFile(filePath);
+  if (currentHash === manifestEntry.hash) {
+    return { status: "unchanged" };
+  }
+  return { status: "modified", currentHash };
+}
+
+// src/manifest/index.ts
+async function readManifest(projectDir) {
+  const manifestPath = path.join(projectDir, MANIFEST_FILENAME);
+  try {
+    const content = await fs2.readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeManifest(projectDir, manifest) {
+  const manifestPath = path.join(projectDir, MANIFEST_FILENAME);
+  await fs2.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+function createEmptyManifest(templateVersion) {
+  return {
+    version: MANIFEST_VERSION,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    templateVersion,
+    files: {},
+    entities: []
+  };
+}
+function setManifestFile(manifest, filePath, entry) {
+  return {
+    ...manifest,
+    files: {
+      ...manifest.files,
+      [filePath]: entry
+    }
+  };
+}
+
+// src/merge/merger.ts
+import diff3Merge from "diff3";
+function performMerge(base, current, generated) {
+  const baseLines = base.split("\n");
+  const currentLines = current.split("\n");
+  const generatedLines = generated.split("\n");
+  const merged = diff3Merge(currentLines, baseLines, generatedLines);
+  const conflicts = [];
+  const outputLines = [];
+  let lineNumber = 1;
+  for (const region of merged) {
+    if (Array.isArray(region)) {
+      outputLines.push(...region);
+      lineNumber += region.length;
+    } else if ("ok" in region && region.ok) {
+      const okLines = region.ok;
+      outputLines.push(...okLines);
+      lineNumber += okLines.length;
+    } else if ("conflict" in region && region.conflict) {
+      const conflictData = region.conflict;
+      const yoursLines = conflictData.a || [];
+      const generatedLines2 = conflictData.b || [];
+      const yours = yoursLines.join("\n");
+      const generatedStr = generatedLines2.join("\n");
+      const conflictLines = [
+        "<<<<<<< YOURS",
+        ...yoursLines,
+        "=======",
+        ...generatedLines2,
+        ">>>>>>> GENERATED"
+      ];
+      const startLine = lineNumber;
+      outputLines.push(...conflictLines);
+      lineNumber += conflictLines.length;
+      conflicts.push({
+        startLine,
+        endLine: lineNumber - 1,
+        yours,
+        generated: generatedStr
+      });
+    }
+  }
+  return {
+    success: conflicts.length === 0,
+    content: outputLines.join("\n"),
+    conflicts
+  };
+}
+
+// src/merge/conflict-writer.ts
+import { writeFile as writeFile2, unlink, access } from "fs/promises";
+import { basename, extname } from "path";
+var CONFLICT_NEW_EXT = ".new";
+var CONFLICT_DIFF_EXT = ".conflict";
+async function writeConflictFiles(filePath, generatedContent, conflicts, currentContent) {
+  const newPath = `${filePath}${CONFLICT_NEW_EXT}`;
+  const conflictPath = `${filePath}${CONFLICT_DIFF_EXT}`;
+  await writeFile2(newPath, generatedContent, "utf-8");
+  const conflictContent = generateConflictFile(
+    filePath,
+    currentContent,
+    generatedContent,
+    conflicts
+  );
+  await writeFile2(conflictPath, conflictContent, "utf-8");
+  return { newPath, conflictPath };
+}
+function generateConflictFile(filePath, _currentContent, _generatedContent, conflicts) {
+  const fileName = basename(filePath);
+  const ext = extname(filePath);
+  const commentStyle = getCommentStyle(ext);
+  const header = `${commentStyle.start}
+${commentStyle.prefix} ${fileName} - MERGE CONFLICT
+${commentStyle.prefix}
+${commentStyle.prefix} This file has ${conflicts.length} conflict(s) that need manual resolution.
+${commentStyle.prefix}
+${commentStyle.prefix} Resolution options:
+${commentStyle.prefix}   1. Edit ${fileName} to include both your changes and the generated changes
+${commentStyle.prefix}   2. Copy desired parts from ${fileName}${CONFLICT_NEW_EXT}
+${commentStyle.prefix}   3. Run 'aerocoding resolve' when done
+${commentStyle.prefix}
+${commentStyle.prefix} Your file: ${fileName} (unchanged)
+${commentStyle.prefix} Generated: ${fileName}${CONFLICT_NEW_EXT} (new version)
+${commentStyle.end}
+
+`;
+  const conflictSections = conflicts.map((conflict, index) => {
+    return `${commentStyle.start}
+${commentStyle.prefix} CONFLICT ${index + 1} of ${conflicts.length} (lines ${conflict.startLine}-${conflict.endLine})
+${commentStyle.end}
+
+<<<<<<< YOURS (keep your changes)
+${conflict.yours}
+=======
+${conflict.generated}
+>>>>>>> GENERATED (from template)
+`;
+  }).join("\n");
+  return header + conflictSections;
+}
+function getCommentStyle(ext) {
+  switch (ext.toLowerCase()) {
+    case ".cs":
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+    case ".java":
+    case ".kt":
+    case ".dart":
+    case ".go":
+    case ".swift":
+    case ".rs":
+    case ".c":
+    case ".cpp":
+    case ".h":
+      return { start: "/*", prefix: " *", end: " */" };
+    case ".py":
+    case ".rb":
+    case ".sh":
+    case ".yaml":
+    case ".yml":
+      return { start: "#", prefix: "#", end: "#" };
+    case ".html":
+    case ".xml":
+    case ".xaml":
+    case ".svg":
+      return { start: "<!--", prefix: " ", end: "-->" };
+    case ".sql":
+      return { start: "--", prefix: "--", end: "--" };
+    case ".css":
+    case ".scss":
+    case ".less":
+      return { start: "/*", prefix: " *", end: " */" };
+    default:
+      return { start: "//", prefix: "//", end: "//" };
+  }
+}
+async function removeConflictFiles(filePath) {
+  const newPath = `${filePath}${CONFLICT_NEW_EXT}`;
+  const conflictPath = `${filePath}${CONFLICT_DIFF_EXT}`;
+  let removedNew = false;
+  let removedConflict = false;
+  try {
+    await unlink(newPath);
+    removedNew = true;
+  } catch {
+  }
+  try {
+    await unlink(conflictPath);
+    removedConflict = true;
+  } catch {
+  }
+  return { removedNew, removedConflict };
+}
+
+// src/utils/file-writer.ts
 function isPathSafe(outputDir, filePath) {
-  const resolvedOutput = path.resolve(outputDir);
-  const resolvedFile = path.resolve(outputDir, filePath);
-  return resolvedFile.startsWith(resolvedOutput + path.sep) || resolvedFile === resolvedOutput;
+  const resolvedOutput = path2.resolve(outputDir);
+  const resolvedFile = path2.resolve(outputDir, filePath);
+  return resolvedFile.startsWith(resolvedOutput + path2.sep) || resolvedFile === resolvedOutput;
 }
 function getCategoryFromPath(filePath) {
   const lowerPath = filePath.toLowerCase();
@@ -601,19 +882,19 @@ async function writeGeneratedFiles(files, outputDir, verbose = false) {
       );
       continue;
     }
-    const fullPath = path.resolve(outputDir, file.path);
-    const dir = path.dirname(fullPath);
+    const fullPath = path2.resolve(outputDir, file.path);
+    const dir = path2.dirname(fullPath);
     if (file.generateOnce) {
       try {
-        await fs.access(fullPath);
+        await fs3.access(fullPath);
         skippedOnceFiles.push(file.path);
         continue;
       } catch {
       }
     }
     try {
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(fullPath, file.content, "utf-8");
+      await fs3.mkdir(dir, { recursive: true });
+      await fs3.writeFile(fullPath, file.content, "utf-8");
       if (verbose) {
         console.log(chalk6.gray(`  ${file.path}`));
       }
@@ -636,12 +917,198 @@ async function writeGeneratedFiles(files, outputDir, verbose = false) {
     }
   }
 }
+function inferFileType(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.includes("/entities/")) return "entity";
+  if (lowerPath.includes("/usecases/") || lowerPath.includes("/use-cases/")) return "usecase";
+  if (lowerPath.includes("/repositories/")) return "repository";
+  if (lowerPath.includes("/controllers/")) return "controller";
+  if (lowerPath.includes("/dtos/") || lowerPath.includes("/dto/")) return "dto";
+  if (lowerPath.includes("/tests/") || lowerPath.includes(".test.") || lowerPath.includes(".spec.")) return "test";
+  if (lowerPath.includes("/config") || lowerPath.includes("appsettings")) return "config";
+  return "other";
+}
+async function writeGeneratedFilesWithManifest(files, outputDir, templateVersion, options = {}) {
+  const { verbose = false, forceOverwrite = false } = options;
+  let manifest = await readManifest(outputDir) || createEmptyManifest(templateVersion);
+  const result = {
+    created: [],
+    updated: [],
+    merged: [],
+    skipped: [],
+    conflicts: [],
+    manifest
+  };
+  for (const file of files) {
+    if (!isPathSafe(outputDir, file.path)) {
+      console.error(chalk6.red(`  Skipping unsafe path: ${file.path}`));
+      continue;
+    }
+    const fullPath = path2.resolve(outputDir, file.path);
+    const dir = path2.dirname(fullPath);
+    const manifestEntry = manifest.files[file.path];
+    const changeStatus = await detectFileChange(fullPath, manifestEntry);
+    let shouldWrite = false;
+    let action = "skip";
+    switch (changeStatus.status) {
+      case "new":
+        shouldWrite = true;
+        action = "create";
+        break;
+      case "unchanged":
+        shouldWrite = true;
+        action = "update";
+        break;
+      case "modified":
+        if (forceOverwrite) {
+          shouldWrite = true;
+          action = "update";
+        } else {
+          const currentContent = await fs3.readFile(fullPath, "utf-8");
+          const mergeResult = performMerge(
+            manifestEntry?.hash ? "" : "",
+            // We don't have base content stored
+            currentContent,
+            file.content
+          );
+          if (mergeResult.success) {
+            shouldWrite = true;
+            action = "update";
+            file._mergedContent = mergeResult.content;
+            result.merged.push(file.path);
+          } else {
+            action = "conflict";
+            await fs3.mkdir(dir, { recursive: true });
+            const { newPath, conflictPath } = await writeConflictFiles(
+              fullPath,
+              file.content,
+              mergeResult.conflicts,
+              currentContent
+            );
+            result.conflicts.push({
+              path: file.path,
+              reason: "Merge conflict - manual resolution required",
+              newPath: path2.relative(outputDir, newPath),
+              conflictPath: path2.relative(outputDir, conflictPath)
+            });
+          }
+        }
+        break;
+      case "deleted":
+        action = "skip";
+        result.skipped.push(file.path);
+        break;
+      case "unknown":
+        action = "skip";
+        result.skipped.push(file.path);
+        break;
+    }
+    if (file.generateOnce && changeStatus.status !== "new") {
+      shouldWrite = false;
+      action = "skip";
+      if (!result.skipped.includes(file.path)) {
+        result.skipped.push(file.path);
+      }
+    }
+    if (shouldWrite) {
+      try {
+        await fs3.mkdir(dir, { recursive: true });
+        const contentToWrite = file._mergedContent || file.content;
+        await fs3.writeFile(fullPath, contentToWrite, "utf-8");
+        const stats = await fs3.stat(fullPath);
+        const entry = {
+          hash: hashString(contentToWrite),
+          mtime: Math.floor(stats.mtimeMs),
+          size: stats.size,
+          entityId: file.entityId,
+          type: file.type || inferFileType(file.path),
+          contextName: file.contextName
+        };
+        manifest = setManifestFile(manifest, file.path, entry);
+        const isMerged = result.merged.includes(file.path);
+        if (action === "create") {
+          result.created.push(file.path);
+          if (verbose) {
+            console.log(chalk6.green(`  \u2713 Created ${file.path}`));
+          }
+        } else if (isMerged) {
+          if (verbose) {
+            console.log(chalk6.magenta(`  \u2713 Merged  ${file.path}`));
+          }
+        } else {
+          result.updated.push(file.path);
+          if (verbose) {
+            console.log(chalk6.blue(`  \u2713 Updated ${file.path}`));
+          }
+        }
+      } catch (error) {
+        console.error(chalk6.red(`  Failed to write ${file.path}`));
+        console.error(chalk6.gray(`    ${error.message}`));
+      }
+    } else if (action === "conflict" && verbose) {
+      console.log(chalk6.yellow(`  \u26A0 Conflict ${file.path}`));
+    }
+  }
+  manifest = {
+    ...manifest,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    templateVersion
+  };
+  await writeManifest(outputDir, manifest);
+  result.manifest = manifest;
+  if (!verbose) {
+    displayIncrementalSummary(result);
+  }
+  return result;
+}
+function displayIncrementalSummary(result) {
+  console.log("");
+  console.log(chalk6.bold("  Update Results"));
+  console.log(chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (result.created.length > 0) {
+    console.log(chalk6.green(`  \u2713 Created:   ${result.created.length} files`));
+  }
+  if (result.updated.length > 0) {
+    console.log(chalk6.blue(`  \u2713 Updated:   ${result.updated.length} files`));
+  }
+  if (result.merged.length > 0) {
+    console.log(chalk6.magenta(`  \u2713 Merged:    ${result.merged.length} files`));
+  }
+  if (result.skipped.length > 0) {
+    console.log(chalk6.gray(`  \u25CB Skipped:   ${result.skipped.length} files`));
+  }
+  if (result.conflicts.length > 0) {
+    console.log(chalk6.yellow(`  \u26A0 Conflicts: ${result.conflicts.length} files`));
+  }
+  console.log(chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  const total = result.created.length + result.updated.length + result.merged.length;
+  console.log(chalk6.white(`  Total written: ${total} files`));
+  if (result.conflicts.length > 0) {
+    console.log("");
+    console.log(chalk6.yellow("  \u26A0 Conflicts need manual resolution:"));
+    console.log("");
+    for (const conflict of result.conflicts.slice(0, 5)) {
+      console.log(chalk6.yellow(`    ${conflict.path}`));
+      if (conflict.newPath) {
+        console.log(chalk6.gray(`      \u2192 ${conflict.newPath}`));
+      }
+      if (conflict.conflictPath) {
+        console.log(chalk6.gray(`      \u2192 ${conflict.conflictPath}`));
+      }
+    }
+    if (result.conflicts.length > 5) {
+      console.log(chalk6.gray(`    ... and ${result.conflicts.length - 5} more`));
+    }
+    console.log("");
+    console.log(chalk6.gray("  Run 'aerocoding resolve' after fixing conflicts."));
+  }
+}
 
 // src/utils/prompt.ts
 import readline from "readline";
 import chalk7 from "chalk";
 function promptConfirm(message) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -649,14 +1116,14 @@ function promptConfirm(message) {
     rl.question(chalk7.yellow(`${message} [Y/n] `), (answer) => {
       rl.close();
       const normalized = answer.trim().toLowerCase();
-      resolve(normalized !== "n" && normalized !== "no");
+      resolve2(normalized !== "n" && normalized !== "no");
     });
   });
 }
 
 // src/config/loader.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs4 from "fs/promises";
+import path3 from "path";
 
 // src/config/schema.ts
 import { z } from "zod";
@@ -688,9 +1155,9 @@ var CONFIG_FILENAME = ".aerocodingrc.json";
 
 // src/config/loader.ts
 async function loadConfig(dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
+  const configPath = path3.join(dir, CONFIG_FILENAME);
   try {
-    const content = await fs2.readFile(configPath, "utf-8");
+    const content = await fs4.readFile(configPath, "utf-8");
     const parsed = JSON.parse(content);
     return configSchema.parse(parsed);
   } catch (error) {
@@ -701,7 +1168,7 @@ async function loadConfig(dir = process.cwd()) {
   }
 }
 async function saveConfig(config, dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
+  const configPath = path3.join(dir, CONFIG_FILENAME);
   const content = JSON.stringify(
     {
       $schema: "https://aerocoding.dev/schemas/aerocodingrc.json",
@@ -710,12 +1177,12 @@ async function saveConfig(config, dir = process.cwd()) {
     null,
     2
   );
-  await fs2.writeFile(configPath, content, "utf-8");
+  await fs4.writeFile(configPath, content, "utf-8");
 }
 async function configExists(dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
+  const configPath = path3.join(dir, CONFIG_FILENAME);
   try {
-    await fs2.access(configPath);
+    await fs4.access(configPath);
     return true;
   } catch {
     return false;
@@ -779,6 +1246,91 @@ function buildFeatureFlagsFromConfig(config) {
   }
   return flags;
 }
+function categorizeFilesByTarget(files) {
+  const backend = [];
+  const frontend = [];
+  for (const file of files) {
+    const ext = file.split(".").pop()?.toLowerCase();
+    if (ext === "cs" || ext === "csproj" || ext === "sln") {
+      backend.push(file);
+    } else if (ext === "dart" || file.includes("pubspec.yaml")) {
+      frontend.push(file);
+    } else if (ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx") {
+      if (file.toLowerCase().includes("frontend") || file.includes(".tsx")) {
+        frontend.push(file);
+      } else {
+        backend.push(file);
+      }
+    } else {
+      if (file.toLowerCase().includes("flutter") || file.toLowerCase().includes("dart")) {
+        frontend.push(file);
+      } else {
+        backend.push(file);
+      }
+    }
+  }
+  return { backend, frontend };
+}
+function displayFileCategories(files) {
+  const categories = categorizeFilePaths(files);
+  const maxNameLength = Math.max(...categories.map((c) => c.name.length));
+  for (const category of categories) {
+    const padding = " ".repeat(maxNameLength - category.name.length + 2);
+    const countStr = category.count.toString().padStart(3, " ");
+    console.log(
+      chalk8.gray(`  ${category.name}${padding}`),
+      chalk8.cyan(`${countStr} files`)
+    );
+  }
+}
+function isBackendFile(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext === "cs" || ext === "csproj" || ext === "sln") {
+    return true;
+  }
+  if (ext === "ts" || ext === "js") {
+    if (filePath.toLowerCase().includes("frontend") || filePath.includes(".tsx")) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isFrontendFile(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext === "dart" || filePath.includes("pubspec.yaml")) {
+    return true;
+  }
+  if (ext === "tsx" || ext === "jsx") {
+    return true;
+  }
+  if ((ext === "ts" || ext === "js") && filePath.toLowerCase().includes("frontend")) {
+    return true;
+  }
+  if (filePath.toLowerCase().includes("flutter") || filePath.toLowerCase().includes("dart")) {
+    return true;
+  }
+  return false;
+}
+function organizeFilesIntoFolders(files, selectedTarget) {
+  return files.map((file) => {
+    let newPath = file.path;
+    if (selectedTarget === "both") {
+      if (isBackendFile(file.path)) {
+        newPath = `backend/${file.path}`;
+      } else if (isFrontendFile(file.path)) {
+        newPath = `frontend/${file.path}`;
+      } else {
+        newPath = `backend/${file.path}`;
+      }
+    } else if (selectedTarget === "backend") {
+      newPath = `backend/${file.path}`;
+    } else if (selectedTarget === "frontend") {
+      newPath = `frontend/${file.path}`;
+    }
+    return { ...file, path: newPath };
+  });
+}
 async function generateCommand(options) {
   const tokenManager = new TokenManager();
   const token = await tokenManager.getAccessToken();
@@ -802,42 +1354,61 @@ async function generateCommand(options) {
   const includeLogging = options.logging ?? config?.codeStyle?.includeLogging ?? true;
   const includeTesting = options.testing ?? config?.codeStyle?.includeTesting ?? true;
   const apiClient = createApiClientWithAutoLogout(token, tokenManager);
-  let spinner2 = ora2({ text: "Fetching project...", color: "cyan" }).start();
+  let spinner5 = ora2({ text: "Fetching project...", color: "cyan" }).start();
   try {
     const project = await apiClient.getProject(projectId);
-    spinner2.succeed(chalk8.gray("Project loaded"));
+    spinner5.succeed(chalk8.gray("Project loaded"));
     const hasBackendConfig = !!config?.backend?.preset;
     const hasFrontendConfig = !!config?.frontend?.preset;
-    const hasBothTargets = hasBackendConfig && hasFrontendConfig;
+    const projectHasBackend = !!project.backendFramework;
+    const projectHasFrontend = !!project.frontendFramework;
+    if (hasBackendConfig && !projectHasBackend) {
+      console.log("");
+      console.log(chalk8.yellow("  \u26A0 Backend is configured but disabled in project settings."));
+      console.log(chalk8.gray("    Enable backend framework at aerocoding.dev or run 'aerocoding init' to reconfigure."));
+    }
+    if (hasFrontendConfig && !projectHasFrontend) {
+      console.log("");
+      console.log(chalk8.yellow("  \u26A0 Frontend is configured but disabled in project settings."));
+      console.log(chalk8.gray("    Enable frontend framework at aerocoding.dev or run 'aerocoding init' to reconfigure."));
+    }
+    const backendAvailable = hasBackendConfig && projectHasBackend;
+    const frontendAvailable = hasFrontendConfig && projectHasFrontend;
+    if (!backendAvailable && !frontendAvailable) {
+      console.log(chalk8.red("\n  No valid targets available."));
+      console.log(chalk8.gray("  Check your project settings at aerocoding.dev and run 'aerocoding init'."));
+      console.log("");
+      process.exit(1);
+    }
+    const hasBothTargets = backendAvailable && frontendAvailable;
     let selectedTarget = "both";
     if (hasBothTargets && !options.all) {
       const targetChoice = await p.select({
         message: "Which target do you want to generate?",
         options: [
+          {
+            value: "both",
+            label: "Both"
+          },
           {
             value: "backend",
-            label: `Backend (${config?.backend?.preset})`,
-            hint: "Recommended"
+            label: `Backend (${config?.backend?.preset})`
           },
           {
             value: "frontend",
             label: `Frontend (${config?.frontend?.preset})`
-          },
-          {
-            value: "both",
-            label: "Both"
           }
         ],
-        initialValue: "backend"
+        initialValue: "both"
       });
       if (p.isCancel(targetChoice)) {
         console.log(chalk8.yellow("\n  Generation cancelled\n"));
         process.exit(0);
       }
       selectedTarget = targetChoice;
-    } else if (hasBackendConfig && !hasFrontendConfig) {
+    } else if (backendAvailable && !frontendAvailable) {
       selectedTarget = "backend";
-    } else if (hasFrontendConfig && !hasBackendConfig) {
+    } else if (frontendAvailable && !backendAvailable) {
       selectedTarget = "frontend";
     }
     const diagrams = project.schema?.diagrams || [];
@@ -885,7 +1456,7 @@ async function generateCommand(options) {
       targets = options.targets || [];
     }
     const featureFlags = buildFeatureFlagsFromConfig(config);
-    spinner2 = ora2({ text: "Checking credits...", color: "cyan" }).start();
+    spinner5 = ora2({ text: "Checking credits...", color: "cyan" }).start();
     const credits = await apiClient.getCreditUsage(project.organizationId);
     const useContexts = config?.architectureStyle !== "flat";
     const estimateDiagramIds = selectedDiagramIds.length < diagrams.length ? selectedDiagramIds : void 0;
@@ -916,7 +1487,7 @@ async function generateCommand(options) {
       }
     } catch {
     }
-    spinner2.succeed(chalk8.gray("Credits verified"));
+    spinner5.succeed(chalk8.gray("Credits verified"));
     if (estimate && estimate.entities === 0) {
       console.log(chalk8.yellow("\n  \u26A0 No entities found in this project."));
       console.log(chalk8.gray("  Create entities in the diagram editor and save (Ctrl+S) before generating.\n"));
@@ -977,26 +1548,32 @@ async function generateCommand(options) {
     }
     console.log(chalk8.gray("  Output:"), chalk8.cyan(output));
     if (estimate && estimate.files && estimate.files.length > 0) {
-      console.log("");
-      console.log(chalk8.bold("  Files to Generate"));
-      console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      const categories = categorizeFilePaths(estimate.files);
-      const maxNameLength = Math.max(...categories.map((c) => c.name.length));
-      for (const category of categories) {
-        const padding = " ".repeat(maxNameLength - category.name.length + 2);
-        const countStr = category.count.toString().padStart(3, " ");
-        console.log(
-          chalk8.gray(`  ${category.name}${padding}`),
-          chalk8.cyan(`${countStr} files`)
-        );
+      const { backend: backendFiles, frontend: frontendFiles } = categorizeFilesByTarget(estimate.files);
+      if ((selectedTarget === "backend" || selectedTarget === "both") && backendFiles.length > 0) {
+        console.log("");
+        console.log(chalk8.bold("  Files to Generate (Backend)"));
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        displayFileCategories(backendFiles);
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk8.gray("  Subtotal:"), chalk8.cyan(`${backendFiles.length} files`));
+      }
+      if ((selectedTarget === "frontend" || selectedTarget === "both") && frontendFiles.length > 0) {
+        console.log("");
+        console.log(chalk8.bold("  Files to Generate (Frontend)"));
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        displayFileCategories(frontendFiles);
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk8.gray("  Subtotal:"), chalk8.cyan(`${frontendFiles.length} files`));
+      }
+      if (selectedTarget === "both" && backendFiles.length > 0 && frontendFiles.length > 0) {
+        console.log("");
+        console.log(chalk8.bold("  Total"));
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk8.gray("  Backend:"), chalk8.cyan(`${backendFiles.length} files`));
+        console.log(chalk8.gray("  Frontend:"), chalk8.cyan(`${frontendFiles.length} files`));
+        console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk8.white("  Total:"), chalk8.bold.cyan(`${estimate.totalFiles} files`));
       }
-      console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      const totalPadding = " ".repeat(maxNameLength - 5 + 2);
-      const totalStr = estimate.totalFiles.toString().padStart(3, " ");
-      console.log(
-        chalk8.white(`  Total${totalPadding}`),
-        chalk8.bold.cyan(`${totalStr} files`)
-      );
       console.log(chalk8.gray(`  Entities:`), chalk8.cyan(estimate.entities));
     }
     console.log("");
@@ -1027,7 +1604,7 @@ async function generateCommand(options) {
       }
     }
     console.log("");
-    spinner2 = ora2({ text: "Generating code...", color: "cyan" }).start();
+    spinner5 = ora2({ text: "Generating code...", color: "cyan" }).start();
     const diagramIds = selectedDiagramIds.length < diagrams.length ? selectedDiagramIds : void 0;
     const generatePayload = templateId ? {
       // NEW: Full architecture mode using template
@@ -1060,7 +1637,7 @@ async function generateCommand(options) {
       }
     };
     const result = await apiClient.generateCode(generatePayload);
-    spinner2.succeed(chalk8.green("Code generated successfully!"));
+    spinner5.succeed(chalk8.green("Code generated successfully!"));
     console.log("");
     console.log(chalk8.bold("  Results"));
     console.log(chalk8.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
@@ -1092,11 +1669,16 @@ async function generateCommand(options) {
       }
     }
     console.log("");
-    await writeGeneratedFiles(result.files, output, options.verbose);
-    console.log(chalk8.green(`  Files written to ${chalk8.white(output)}`));
+    const organizedFiles = organizeFilesIntoFolders(result.files, selectedTarget);
+    await writeGeneratedFiles(organizedFiles, output, options.verbose);
+    if (selectedTarget === "both") {
+      console.log(chalk8.green(`  Files written to ${chalk8.white(output)}/backend and ${chalk8.white(output)}/frontend`));
+    } else {
+      console.log(chalk8.green(`  Files written to ${chalk8.white(output)}/${selectedTarget}`));
+    }
     console.log("");
   } catch (error) {
-    spinner2.fail(chalk8.red("Generation failed"));
+    spinner5.fail(chalk8.red("Generation failed"));
     if (error.response?.status === 401) {
       await handleUnauthorized(tokenManager);
     } else if (error.response?.status === 403) {
@@ -1178,10 +1760,10 @@ async function initCommand(options) {
     }
     let projectId = options.project;
     if (!projectId) {
-      const spinner3 = p2.spinner();
-      spinner3.start("Loading projects...");
+      const spinner6 = p2.spinner();
+      spinner6.start("Loading projects...");
       const projects = await apiClient.listProjects(organizationId);
-      spinner3.stop("Projects loaded");
+      spinner6.stop("Projects loaded");
       if (projects.length === 0) {
         p2.cancel("No projects in this organization. Create one on aerocoding.dev first.");
         process.exit(1);
@@ -1200,10 +1782,10 @@ async function initCommand(options) {
       }
       projectId = selectedProject;
     }
-    const spinner2 = p2.spinner();
-    spinner2.start("Fetching project details...");
+    const spinner5 = p2.spinner();
+    spinner5.start("Fetching project details...");
     const project = await apiClient.getProject(projectId);
-    spinner2.stop(`Project: ${project.name}`);
+    spinner5.stop(`Project: ${project.name}`);
     const hasBackend = !!project.backendFramework;
     const hasFrontend = !!project.frontendFramework;
     if (!hasBackend && !hasFrontend) {
@@ -1358,31 +1940,818 @@ async function initCommand(options) {
   }
 }
 
-// src/commands/pull.ts
+// src/commands/create.ts
+import * as p3 from "@clack/prompts";
 import chalk10 from "chalk";
+import ora3 from "ora";
+import { mkdir, access as access3 } from "fs/promises";
+import { resolve } from "path";
+
+// src/config/project-config.ts
+import { z as z2 } from "zod";
+import { readFile as readFile2, writeFile as writeFile3, access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+var PROJECT_CONFIG_FILENAME = "aerocoding.json";
+var projectConfigSchema = z2.object({
+  $schema: z2.string().optional().default("https://aerocoding.dev/schema.json"),
+  /** Project UUID from aerocoding.dev */
+  projectId: z2.string().uuid(),
+  /** Template ID for architecture generation */
+  templateId: z2.string().min(1),
+  /** Template version at project creation */
+  templateVersion: z2.string().optional(),
+  /** Root namespace/package name */
+  namespace: z2.string().min(1),
+  /** Output directories */
+  output: z2.object({
+    backend: z2.string().default("./backend"),
+    frontend: z2.string().default("./frontend")
+  }).optional().default({ backend: "./backend", frontend: "./frontend" }),
+  /** Organization ID (for cloud sync) */
+  organizationId: z2.string().uuid().optional()
+});
+async function loadProjectConfig(dir = process.cwd()) {
+  try {
+    const configPath = join2(dir, PROJECT_CONFIG_FILENAME);
+    const content = await readFile2(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return projectConfigSchema.parse(parsed);
+  } catch {
+    return null;
+  }
+}
+async function saveProjectConfig(config, dir = process.cwd()) {
+  const configPath = join2(dir, PROJECT_CONFIG_FILENAME);
+  const content = JSON.stringify(config, null, 2);
+  await writeFile3(configPath, content, "utf-8");
+}
+function createProjectConfig(options) {
+  return {
+    $schema: "https://aerocoding.dev/schema.json",
+    projectId: options.projectId,
+    templateId: options.templateId,
+    templateVersion: options.templateVersion,
+    namespace: options.namespace,
+    organizationId: options.organizationId,
+    output: {
+      backend: options.output?.backend || "./backend",
+      frontend: options.output?.frontend || "./frontend"
+    }
+  };
+}
+
+// src/utils/cloud-sync.ts
+function toCloudManifest(manifest) {
+  return {
+    version: manifest.version,
+    lastSync: manifest.lastSync,
+    templateVersion: manifest.templateVersion,
+    files: manifest.files
+  };
+}
+function fromCloudManifest(cloudManifest, templateVersion) {
+  return {
+    version: cloudManifest.version,
+    lastSync: cloudManifest.lastSync || (/* @__PURE__ */ new Date()).toISOString(),
+    templateVersion: cloudManifest.templateVersion || templateVersion,
+    files: cloudManifest.files,
+    entities: []
+    // Will be rebuilt on next generation
+  };
+}
+async function syncToCloud(apiClient, projectId, manifest) {
+  const cloudManifest = toCloudManifest(manifest);
+  const result = await apiClient.saveManifest(projectId, cloudManifest);
+  return {
+    success: result.success,
+    fileCount: result.fileCount
+  };
+}
+async function fetchFromCloud(apiClient, projectId, templateVersion) {
+  const cloudManifest = await apiClient.getManifest(projectId);
+  if (!cloudManifest) {
+    return null;
+  }
+  return fromCloudManifest(cloudManifest, templateVersion);
+}
+async function compareWithCloud(apiClient, projectId, localManifest) {
+  const cloudManifest = await apiClient.getManifest(projectId);
+  const cloudLastSync = cloudManifest?.lastSync || null;
+  const localLastSync = localManifest?.lastSync || null;
+  const cloudFileCount = cloudManifest ? Object.keys(cloudManifest.files).length : 0;
+  const localFileCount = localManifest ? Object.keys(localManifest.files).length : 0;
+  let isCloudNewer = false;
+  if (cloudLastSync && localLastSync) {
+    isCloudNewer = new Date(cloudLastSync) > new Date(localLastSync);
+  } else if (cloudLastSync && !localLastSync) {
+    isCloudNewer = true;
+  }
+  return {
+    hasCloudBackup: cloudManifest !== null,
+    cloudLastSync,
+    localLastSync,
+    isCloudNewer,
+    cloudFileCount,
+    localFileCount
+  };
+}
+function formatSyncDate(isoDate) {
+  if (!isoDate) return "never";
+  const date = new Date(isoDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+// src/commands/create.ts
+async function createCommand(projectName, options) {
+  p3.intro(chalk10.bgCyan.black(" AeroCoding Create "));
+  if (!projectName || projectName.trim() === "") {
+    p3.cancel("Project name is required");
+    process.exit(1);
+  }
+  const safeName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!safeName) {
+    p3.cancel("Invalid project name. Use alphanumeric characters and hyphens.");
+    process.exit(1);
+  }
+  const projectDir = resolve(process.cwd(), safeName);
+  try {
+    await access3(projectDir);
+    if (!options.force) {
+      const overwrite = await p3.confirm({
+        message: `Directory '${safeName}' already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p3.isCancel(overwrite) || !overwrite) {
+        p3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+  } catch {
+  }
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    p3.cancel("Not logged in. Run 'aerocoding login' first.");
+    process.exit(1);
+  }
+  const apiClient = createApiClientWithAutoLogout(token, tokenManager);
+  try {
+    const orgSpinner = p3.spinner();
+    orgSpinner.start("Loading organizations...");
+    const organizations = await apiClient.listOrganizations();
+    orgSpinner.stop("Organizations loaded");
+    if (organizations.length === 0) {
+      p3.cancel("No organizations found. Create one on aerocoding.dev first.");
+      process.exit(1);
+    }
+    let organizationId;
+    if (organizations.length === 1 && organizations[0]) {
+      organizationId = organizations[0].id;
+      p3.log.info(`Organization: ${organizations[0].name}`);
+    } else {
+      const selectedOrg = await p3.select({
+        message: "Select organization",
+        options: organizations.map((org) => ({
+          value: org.id,
+          label: org.name,
+          hint: org.planTier.toUpperCase()
+        }))
+      });
+      if (p3.isCancel(selectedOrg)) {
+        p3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      organizationId = selectedOrg;
+    }
+    let projectId = options.project;
+    if (!projectId) {
+      const spinner5 = p3.spinner();
+      spinner5.start("Loading projects...");
+      const projects = await apiClient.listProjects(organizationId);
+      spinner5.stop("Projects loaded");
+      if (projects.length === 0) {
+        p3.cancel("No projects in this organization. Create one on aerocoding.dev first.");
+        process.exit(1);
+      }
+      const selectedProject = await p3.select({
+        message: "Select project to generate from",
+        options: projects.map((proj) => ({
+          value: proj.id,
+          label: proj.name,
+          hint: [proj.backendFramework, proj.frontendFramework].filter(Boolean).join(" + ")
+        }))
+      });
+      if (p3.isCancel(selectedProject)) {
+        p3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      projectId = selectedProject;
+    }
+    const projectSpinner = p3.spinner();
+    projectSpinner.start("Fetching project details...");
+    const project = await apiClient.getProject(projectId);
+    projectSpinner.stop(`Project: ${project.name}`);
+    let templateId = options.template;
+    if (!templateId) {
+      const templateSpinner = p3.spinner();
+      templateSpinner.start("Loading templates...");
+      const templateResult = await apiClient.getTemplates({
+        category: "backend",
+        language: project.backendFramework || void 0
+      });
+      templateSpinner.stop("Templates loaded");
+      if (templateResult.templates.length === 0) {
+        p3.cancel("No templates available for this project's framework.");
+        process.exit(1);
+      }
+      const selectedTemplate = await p3.select({
+        message: "Select architecture template",
+        options: templateResult.templates.map((tmpl) => ({
+          value: tmpl.id,
+          label: tmpl.name,
+          hint: tmpl.description || `${tmpl.tier} tier`
+        }))
+      });
+      if (p3.isCancel(selectedTemplate)) {
+        p3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      templateId = selectedTemplate;
+    }
+    const namespace = await p3.text({
+      message: "Root namespace/package name",
+      placeholder: "MegaStore",
+      initialValue: toPascalCase(project.name),
+      validate: (value) => {
+        if (!value || value.trim() === "") return "Namespace is required";
+        if (!/^[A-Za-z][A-Za-z0-9]*$/.test(value)) {
+          return "Namespace must start with a letter and contain only alphanumeric characters";
+        }
+        return void 0;
+      }
+    });
+    if (p3.isCancel(namespace)) {
+      p3.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    p3.log.step(chalk10.bold("Configuration Summary:"));
+    p3.log.info(`  Directory: ${safeName}/`);
+    p3.log.info(`  Project: ${project.name}`);
+    p3.log.info(`  Template: ${templateId}`);
+    p3.log.info(`  Namespace: ${namespace}`);
+    const proceed = await p3.confirm({
+      message: "Create project with these settings?",
+      initialValue: true
+    });
+    if (p3.isCancel(proceed) || !proceed) {
+      p3.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const dirSpinner = p3.spinner();
+    dirSpinner.start(`Creating ${safeName}/...`);
+    await mkdir(projectDir, { recursive: true });
+    dirSpinner.stop(`Created ${safeName}/`);
+    const genSpinner = ora3({ text: "Generating architecture...", color: "cyan" }).start();
+    const result = await apiClient.generateCode({
+      projectId,
+      templateId,
+      options: {
+        includeValidations: true,
+        includeComments: true,
+        featureFlags: {
+          includeDtos: true,
+          includeUseCases: true,
+          includeMappers: true,
+          includeControllers: true,
+          includeEfConfig: true,
+          includeValidation: true,
+          includeDtoValidation: true,
+          includeUnitTests: true,
+          includeIntegrationTests: true,
+          includeStarterFiles: false
+        },
+        useContexts: true
+      }
+    });
+    genSpinner.succeed(chalk10.green(`Generated ${result.files?.length || 0} files`));
+    const writeSpinner = p3.spinner();
+    writeSpinner.start("Writing files...");
+    const organizedFiles = result.files.map((file) => ({
+      ...file,
+      path: `backend/${file.path}`
+    }));
+    await writeGeneratedFiles(organizedFiles, projectDir, false);
+    writeSpinner.stop(`Wrote ${organizedFiles.length} files`);
+    const configSpinner = p3.spinner();
+    configSpinner.start("Creating config files...");
+    const projectConfig = createProjectConfig({
+      projectId,
+      templateId,
+      templateVersion: "1.0.0",
+      // TODO: get from template
+      namespace,
+      organizationId,
+      output: { backend: "./backend", frontend: "./frontend" }
+    });
+    await saveProjectConfig(projectConfig, projectDir);
+    let manifest = createEmptyManifest("1.0.0");
+    for (const file of organizedFiles) {
+      const hash = hashString(file.content);
+      manifest = setManifestFile(manifest, file.path, {
+        hash,
+        mtime: Date.now(),
+        size: Buffer.byteLength(file.content, "utf-8"),
+        type: detectFileType(file.path)
+      });
+    }
+    await writeManifest(projectDir, manifest);
+    configSpinner.stop("Config files created");
+    try {
+      const syncResult = await syncToCloud(apiClient, projectId, manifest);
+      if (syncResult.success) {
+        console.log(
+          chalk10.gray("  \u2713 Manifest synced to cloud") + chalk10.gray(` (${syncResult.fileCount} files)`)
+        );
+      }
+    } catch {
+      console.log(chalk10.yellow("  \u26A0 Could not sync manifest to cloud"));
+    }
+    console.log("");
+    console.log(chalk10.bold("  Project Created Successfully!"));
+    console.log(chalk10.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk10.gray("  Directory:"), chalk10.cyan(safeName + "/"));
+    console.log(chalk10.gray("  Files:"), chalk10.cyan(organizedFiles.length));
+    console.log(chalk10.gray("  Config:"), chalk10.cyan(PROJECT_CONFIG_FILENAME));
+    console.log(chalk10.gray("  Manifest:"), chalk10.cyan(MANIFEST_FILENAME));
+    if (result.creditsUsed !== void 0) {
+      console.log("");
+      console.log(chalk10.gray("  Credits used:"), chalk10.yellow(result.creditsUsed));
+      console.log(chalk10.gray("  Credits remaining:"), chalk10.green(result.creditsRemaining));
+    }
+    p3.outro(
+      chalk10.green("Project ready!") + "\n\n" + chalk10.gray("  Next steps:\n") + chalk10.cyan(`    cd ${safeName}
+`) + chalk10.gray("    # Make changes in the diagram editor\n") + chalk10.cyan("    aerocoding update") + chalk10.gray("  # Sync changes incrementally")
+    );
+  } catch (error) {
+    const err = error;
+    if (err.response?.status === 401) {
+      await handleUnauthorized(tokenManager);
+    } else if (err.response?.data?.message) {
+      p3.cancel(err.response.data.message);
+    } else {
+      p3.cancel(err.message || "An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function detectFileType(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.includes("/entities/") || lower.includes("/domain/")) return "entity";
+  if (lower.includes("/usecases/") || lower.includes("/application/")) return "usecase";
+  if (lower.includes("/repositories/")) return "repository";
+  if (lower.includes("/controllers/") || lower.includes("/api/")) return "controller";
+  if (lower.includes("/dtos/") || lower.includes("/dto/")) return "dto";
+  if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("/tests/")) return "test";
+  if (lower.includes("/config/") || lower.includes("appsettings") || lower.includes(".csproj")) return "config";
+  return "other";
+}
+
+// src/commands/update.ts
+import * as p4 from "@clack/prompts";
+import chalk11 from "chalk";
+import ora4 from "ora";
+async function updateCommand(options) {
+  p4.intro(chalk11.bgCyan.black(" AeroCoding Update "));
+  const config = await loadProjectConfig();
+  if (!config) {
+    p4.cancel(
+      `No ${PROJECT_CONFIG_FILENAME} found. Run 'aerocoding create' first.`
+    );
+    process.exit(1);
+  }
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    p4.cancel("Not logged in. Run 'aerocoding login' first.");
+    process.exit(1);
+  }
+  const apiClient = createApiClientWithAutoLogout(token, tokenManager);
+  try {
+    let manifest = await readManifest(process.cwd());
+    let fileCount = manifest ? Object.keys(manifest.files).length : 0;
+    if (manifest) {
+      p4.log.info(
+        `Found manifest with ${fileCount} tracked files (last sync: ${manifest.lastSync || "unknown"})`
+      );
+    } else {
+      p4.log.warn("No local manifest found.");
+      const cloudCheck = await compareWithCloud(apiClient, config.projectId, null);
+      if (cloudCheck.hasCloudBackup) {
+        p4.log.info(
+          chalk11.cyan(
+            `  Cloud backup available (${cloudCheck.cloudFileCount} files, synced ${formatSyncDate(cloudCheck.cloudLastSync)})`
+          )
+        );
+        const recovery = await p4.select({
+          message: "How would you like to proceed?",
+          options: [
+            {
+              value: "restore",
+              label: "Restore from cloud backup",
+              hint: "recommended"
+            },
+            {
+              value: "continue",
+              label: "Continue anyway",
+              hint: "all files will be treated as new"
+            },
+            { value: "cancel", label: "Cancel" }
+          ]
+        });
+        if (p4.isCancel(recovery) || recovery === "cancel") {
+          p4.cancel("Update cancelled.");
+          process.exit(0);
+        }
+        if (recovery === "restore") {
+          const restoreSpinner = p4.spinner();
+          restoreSpinner.start("Restoring manifest from cloud...");
+          const cloudManifest = await fetchFromCloud(
+            apiClient,
+            config.projectId,
+            config.templateVersion || "1.0.0"
+          );
+          if (cloudManifest) {
+            await writeManifest(process.cwd(), cloudManifest);
+            manifest = cloudManifest;
+            fileCount = Object.keys(manifest.files).length;
+            restoreSpinner.stop(
+              chalk11.green(`Restored ${fileCount} files from cloud backup`)
+            );
+          } else {
+            restoreSpinner.stop(chalk11.yellow("Cloud backup not found"));
+          }
+        }
+      } else {
+        p4.log.info(
+          chalk11.gray("  No cloud backup available. All generated files will be created as new.")
+        );
+      }
+    }
+    const projectSpinner = p4.spinner();
+    projectSpinner.start("Fetching project details...");
+    const project = await apiClient.getProject(config.projectId);
+    projectSpinner.stop(`Project: ${project.name}`);
+    p4.log.step(chalk11.bold("Update Configuration:"));
+    p4.log.info(`  Project: ${project.name}`);
+    p4.log.info(`  Template: ${config.templateId}`);
+    p4.log.info(`  Namespace: ${config.namespace}`);
+    p4.log.info(`  Output: ${config.output.backend}`);
+    if (options.dryRun) {
+      p4.log.info(chalk11.yellow("  Mode: DRY RUN (no files will be written)"));
+    }
+    if (options.force) {
+      p4.log.info(chalk11.yellow("  Mode: FORCE (will overwrite modified files)"));
+    }
+    if (!options.dryRun) {
+      const proceed = await p4.confirm({
+        message: "Proceed with update?",
+        initialValue: true
+      });
+      if (p4.isCancel(proceed) || !proceed) {
+        p4.cancel("Update cancelled.");
+        process.exit(0);
+      }
+    }
+    const genSpinner = ora4({
+      text: "Generating code from latest schema...",
+      color: "cyan"
+    }).start();
+    const result = await apiClient.generateCode({
+      projectId: config.projectId,
+      templateId: config.templateId,
+      options: {
+        includeValidations: true,
+        includeComments: true,
+        featureFlags: {
+          includeDtos: true,
+          includeUseCases: true,
+          includeMappers: true,
+          includeControllers: true,
+          includeEfConfig: true,
+          includeValidation: true,
+          includeDtoValidation: true,
+          includeUnitTests: true,
+          includeIntegrationTests: true,
+          includeStarterFiles: false
+          // Don't regenerate starter files
+        },
+        useContexts: true
+      }
+    });
+    genSpinner.succeed(
+      chalk11.green(`Generated ${result.files?.length || 0} files from schema`)
+    );
+    if (options.dryRun) {
+      p4.log.info("");
+      p4.log.info(chalk11.bold("  Dry Run Results:"));
+      p4.log.info(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      p4.log.info(`  Files to process: ${result.files?.length || 0}`);
+      p4.log.info(`  Tracked files: ${fileCount}`);
+      p4.log.info("");
+      p4.log.info(chalk11.gray("  Run without --dry-run to apply changes."));
+      p4.outro(chalk11.green("Dry run complete!"));
+      return;
+    }
+    const updateSpinner = p4.spinner();
+    updateSpinner.start("Applying updates...");
+    const organizedFiles = result.files.map(
+      (file) => ({
+        ...file,
+        path: `${config.output.backend.replace(/^\.\//, "")}/${file.path}`
+      })
+    );
+    const writeResult = await writeGeneratedFilesWithManifest(
+      organizedFiles,
+      process.cwd(),
+      config.templateVersion || "1.0.0",
+      {
+        verbose: options.verbose,
+        forceOverwrite: options.force
+      }
+    );
+    updateSpinner.stop("Update complete");
+    if (result.creditsUsed !== void 0) {
+      console.log("");
+      console.log(chalk11.gray("  Credits used:"), chalk11.yellow(result.creditsUsed));
+      console.log(
+        chalk11.gray("  Credits remaining:"),
+        chalk11.green(result.creditsRemaining)
+      );
+    }
+    try {
+      const syncResult = await syncToCloud(
+        apiClient,
+        config.projectId,
+        writeResult.manifest
+      );
+      if (syncResult.success) {
+        console.log(
+          chalk11.gray("  \u2713 Manifest synced to cloud") + chalk11.gray(` (${syncResult.fileCount} files)`)
+        );
+      }
+    } catch (syncError) {
+      console.log(chalk11.yellow("  \u26A0 Could not sync manifest to cloud"));
+      if (options.verbose) {
+        console.log(chalk11.gray(`    ${syncError.message}`));
+      }
+    }
+    if (writeResult.conflicts.length > 0) {
+      p4.outro(
+        chalk11.yellow(`Update complete with ${writeResult.conflicts.length} conflict(s).`) + "\n" + chalk11.gray("  Run 'aerocoding resolve' after fixing conflicts.")
+      );
+    } else {
+      const totalWritten = writeResult.created.length + writeResult.updated.length + writeResult.merged.length;
+      p4.outro(
+        chalk11.green(`Update complete! ${totalWritten} file(s) written.`)
+      );
+    }
+  } catch (error) {
+    const err = error;
+    if (err.response?.status === 401) {
+      await handleUnauthorized(tokenManager);
+    } else if (err.response?.data?.message) {
+      p4.cancel(err.response.data.message);
+    } else {
+      p4.cancel(err.message || "An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/resolve.ts
+import * as p5 from "@clack/prompts";
+import chalk12 from "chalk";
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3, relative } from "path";
+async function resolveCommand(options) {
+  p5.intro(chalk12.bgCyan.black(" AeroCoding Resolve "));
+  const config = await loadProjectConfig();
+  if (!config) {
+    p5.cancel(
+      `No ${PROJECT_CONFIG_FILENAME} found. Run 'aerocoding create' first.`
+    );
+    process.exit(1);
+  }
+  const spinner5 = p5.spinner();
+  spinner5.start("Scanning for conflict files...");
+  const conflicts = await findConflictFiles(process.cwd());
+  spinner5.stop(`Found ${conflicts.length} conflict(s)`);
+  if (conflicts.length === 0) {
+    p5.log.success("No conflicts to resolve!");
+    p5.outro(chalk12.green("All clear!"));
+    return;
+  }
+  p5.log.info("");
+  p5.log.info(chalk12.bold("  Pending Conflicts:"));
+  p5.log.info(chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  for (const conflict of conflicts) {
+    const relPath = relative(process.cwd(), conflict.originalPath);
+    p5.log.info(chalk12.yellow(`  \u26A0 ${relPath}`));
+    if (options.verbose) {
+      p5.log.info(chalk12.gray(`      \u2192 ${relative(process.cwd(), conflict.newPath)}`));
+      p5.log.info(
+        chalk12.gray(`      \u2192 ${relative(process.cwd(), conflict.conflictPath)}`)
+      );
+    }
+  }
+  p5.log.info(chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  p5.log.info("");
+  if (!options.all) {
+    const proceed = await p5.confirm({
+      message: `Remove ${conflicts.length} conflict file(s)? (This assumes you've resolved them)`,
+      initialValue: true
+    });
+    if (p5.isCancel(proceed) || !proceed) {
+      p5.cancel("Resolution cancelled.");
+      process.exit(0);
+    }
+  }
+  let manifest = await readManifest(process.cwd());
+  if (!manifest) {
+    p5.cancel("No manifest found. Cannot update file hashes.");
+    process.exit(1);
+  }
+  const resolveSpinner = p5.spinner();
+  resolveSpinner.start("Resolving conflicts...");
+  let resolved = 0;
+  let failed = 0;
+  for (const conflict of conflicts) {
+    try {
+      const relPath = relative(process.cwd(), conflict.originalPath);
+      try {
+        await stat2(conflict.originalPath);
+      } catch {
+        if (options.verbose) {
+          console.log(
+            chalk12.red(`  \u2717 ${relPath} - original file not found`)
+          );
+        }
+        failed++;
+        continue;
+      }
+      const { removedNew, removedConflict } = await removeConflictFiles(
+        conflict.originalPath
+      );
+      const newHash = await hashFile(conflict.originalPath);
+      const stats = await stat2(conflict.originalPath);
+      const manifestPath = relPath.replace(/\\/g, "/");
+      const existingEntry = manifest.files[manifestPath];
+      manifest = setManifestFile(manifest, manifestPath, {
+        hash: newHash,
+        mtime: Math.floor(stats.mtimeMs),
+        size: stats.size,
+        entityId: existingEntry?.entityId,
+        type: existingEntry?.type || "other",
+        contextName: existingEntry?.contextName
+      });
+      if (options.verbose) {
+        const removed = [];
+        if (removedNew) removed.push(".new");
+        if (removedConflict) removed.push(".conflict");
+        console.log(
+          chalk12.green(`  \u2713 ${relPath}`) + chalk12.gray(` (removed ${removed.join(", ")})`)
+        );
+      }
+      resolved++;
+    } catch (error) {
+      failed++;
+      if (options.verbose) {
+        const relPath = relative(process.cwd(), conflict.originalPath);
+        console.log(chalk12.red(`  \u2717 ${relPath} - ${error}`));
+      }
+    }
+  }
+  manifest = {
+    ...manifest,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeManifest(process.cwd(), manifest);
+  resolveSpinner.stop("Conflicts resolved");
+  console.log("");
+  console.log(chalk12.bold("  Resolution Results"));
+  console.log(chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (resolved > 0) {
+    console.log(chalk12.green(`  \u2713 Resolved: ${resolved} files`));
+  }
+  if (failed > 0) {
+    console.log(chalk12.red(`  \u2717 Failed:   ${failed} files`));
+  }
+  console.log(chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (failed > 0) {
+    p5.outro(
+      chalk12.yellow(
+        `Resolved ${resolved} conflict(s), ${failed} failed.`
+      )
+    );
+  } else {
+    p5.outro(chalk12.green(`All ${resolved} conflict(s) resolved!`));
+  }
+}
+async function findConflictFiles(dir) {
+  const conflicts = [];
+  async function scan(currentDir) {
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join3(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".")) {
+            continue;
+          }
+          await scan(fullPath);
+        } else if (entry.isFile()) {
+          if (entry.name.endsWith(CONFLICT_NEW_EXT)) {
+            const originalPath = fullPath.slice(
+              0,
+              -CONFLICT_NEW_EXT.length
+            );
+            const conflictPath = originalPath + CONFLICT_DIFF_EXT;
+            const existing = conflicts.find(
+              (c) => c.originalPath === originalPath
+            );
+            if (!existing) {
+              conflicts.push({
+                originalPath,
+                newPath: fullPath,
+                conflictPath
+              });
+            }
+          } else if (entry.name.endsWith(CONFLICT_DIFF_EXT)) {
+            const originalPath = fullPath.slice(
+              0,
+              -CONFLICT_DIFF_EXT.length
+            );
+            const newPath = originalPath + CONFLICT_NEW_EXT;
+            const existing = conflicts.find(
+              (c) => c.originalPath === originalPath
+            );
+            if (!existing) {
+              conflicts.push({
+                originalPath,
+                newPath,
+                conflictPath: fullPath
+              });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await scan(dir);
+  return conflicts;
+}
+
+// src/commands/pull.ts
+import chalk13 from "chalk";
 async function pullCommand(options) {
-  console.log(chalk10.yellow("Command not yet implemented"));
+  console.log(chalk13.yellow("Command not yet implemented"));
   if (options.project) {
-    console.log(chalk10.gray(`  Requested project: ${options.project}`));
+    console.log(chalk13.gray(`  Requested project: ${options.project}`));
   }
-  console.log(chalk10.gray("  Coming soon in v0.2.0\n"));
+  console.log(chalk13.gray("  Coming soon in v0.2.0\n"));
 }
 
 // src/commands/status.ts
-import chalk11 from "chalk";
+import chalk14 from "chalk";
 async function statusCommand() {
-  console.log(chalk11.yellow("Command not yet implemented"));
-  console.log(chalk11.gray("  Coming soon in v0.2.0\n"));
+  console.log(chalk14.yellow("Command not yet implemented"));
+  console.log(chalk14.gray("  Coming soon in v0.2.0\n"));
 }
 
 // src/index.ts
 import "dotenv/config";
 var program = new Command();
-program.name("aerocoding").description("AeroCoding CLI - Generate production-ready code from UML diagrams").version("0.1.23");
+program.name("aerocoding").description("AeroCoding CLI - Generate production-ready code from UML diagrams").version("0.1.24");
 program.command("login").description("Authenticate with AeroCoding").action(loginCommand);
 program.command("logout").description("Logout and clear stored credentials").action(logoutCommand);
 program.command("whoami").description("Show current authenticated user").action(whoamiCommand);
 program.command("init").description("Initialize AeroCoding in current directory").option("-p, --project <id>", "Project ID (skip selection)").option("-f, --force", "Overwrite existing config without asking").action(initCommand);
+program.command("create <name>").description("Create a new AeroCoding project with full architecture").option("-t, --template <id>", "Template ID (skip selection)").option("-p, --project <id>", "Project ID (skip selection)").option("-f, --force", "Overwrite existing directory without asking").action(createCommand);
+program.command("update").description("Update generated code incrementally (preserves your changes)").option("-f, --force", "Overwrite modified files without merging").option("-v, --verbose", "Show detailed file operations").option("--dry-run", "Preview changes without writing files").action(updateCommand);
+program.command("resolve").description("Clean up conflict files after manual resolution").option("-v, --verbose", "Show detailed resolution info").option("-a, --all", "Resolve all conflicts without confirmation").action(resolveCommand);
 program.command("pull").description("Pull schema from cloud").option("-p, --project <id>", "Project ID").action(pullCommand);
 program.command("status").description("Show local schema status").action(statusCommand);
 program.command("generate").alias("gen").description("Generate code from schema").option("-p, --project <id>", "Project ID").option("-t, --targets <targets...>", "Generation targets (e.g., dotnet-entity)").option("-e, --entities <entities...>", "Filter by entity names").option("-o, --output <dir>", "Output directory", "./.aerocoding").option("--backend-preset <preset>", "Backend architecture preset").option("--frontend-preset <preset>", "Frontend architecture preset").option("--backend-layers <layers...>", "Backend layers to generate").option("--frontend-layers <layers...>", "Frontend layers to generate").option("--no-validations", "Exclude validations").option("--no-comments", "Exclude comments").option("--no-annotations", "Exclude annotations").option("--no-logging", "Exclude logging statements").option("--no-testing", "Exclude test files").option("--validation-lib <framework>", "Validation library (e.g., fluentvalidation, zod, formz)").option("-v, --verbose", "Show all generated file paths").option("-y, --yes", "Skip confirmation prompt").option("-a, --all", "Generate all bounded contexts and targets without prompting").action(generateCommand);