aerocoding 0.1.23 → 0.1.25

package/dist/index.js

@@ -81,7 +81,7 @@ var DeviceFlow = class {
    * Step 3: Poll for token
    */
   async pollForToken(auth) {
-    const spinner2 = ora({
+    const spinner4 = 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"));
+        spinner4.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!"));
+        spinner4.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)";
+          spinner4.text = "Polling... (slowed down to avoid spam)";
           await this.sleep(currentInterval);
           continue;
         }
         if (errorCode === "expired_token") {
-          spinner2.fail(chalk.red("Authorization code expired"));
+          spinner4.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"));
+          spinner4.fail(chalk.red("Authorization denied"));
           throw new Error("You denied the authorization request");
         }
-        spinner2.fail(chalk.red("Authorization failed"));
+        spinner4.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
@@ -514,19 +542,274 @@ async function whoamiCommand() {
   }
 }
 
-// src/commands/generate.ts
-import chalk8 from "chalk";
-import ora2 from "ora";
+// src/commands/create.ts
 import * as p from "@clack/prompts";
+import chalk7 from "chalk";
+import ora2 from "ora";
+import { mkdir, access as access3 } from "fs/promises";
+import { resolve } from "path";
 
 // 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 +884,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,533 +919,341 @@ async function writeGeneratedFiles(files, outputDir, verbose = false) {
     }
   }
 }
-
-// src/utils/prompt.ts
-import readline from "readline";
-import chalk7 from "chalk";
-function promptConfirm(message) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.question(chalk7.yellow(`${message} [Y/n] `), (answer) => {
-      rl.close();
-      const normalized = answer.trim().toLowerCase();
-      resolve(normalized !== "n" && normalized !== "no");
-    });
-  });
-}
-
-// src/config/loader.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// src/config/schema.ts
-import { z } from "zod";
-var configSchema = z.object({
-  $schema: z.string().optional(),
-  project: z.string().uuid(),
-  output: z.string().default("./.aerocoding"),
-  // Architecture style: how to organize generated code
-  architectureStyle: z.enum(["bounded-contexts", "flat"]).optional().default("bounded-contexts"),
-  backend: z.object({
-    preset: z.string()
-  }).optional(),
-  frontend: z.object({
-    preset: z.string()
-  }).optional(),
-  codeStyle: z.object({
-    includeValidations: z.boolean().default(true),
-    includeComments: z.boolean().default(true),
-    includeLogging: z.boolean().default(true),
-    includeTesting: z.boolean().default(true)
-  }).optional(),
-  libraries: z.object({
-    validation: z.string().optional(),
-    logging: z.string().optional()
-  }).optional(),
-  excludePatterns: z.array(z.string()).optional()
-});
-var CONFIG_FILENAME = ".aerocodingrc.json";
-
-// src/config/loader.ts
-async function loadConfig(dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
-  try {
-    const content = await fs2.readFile(configPath, "utf-8");
-    const parsed = JSON.parse(content);
-    return configSchema.parse(parsed);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function saveConfig(config, dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
-  const content = JSON.stringify(
-    {
-      $schema: "https://aerocoding.dev/schemas/aerocodingrc.json",
-      ...config
-    },
-    null,
-    2
-  );
-  await fs2.writeFile(configPath, content, "utf-8");
-}
-async function configExists(dir = process.cwd()) {
-  const configPath = path2.join(dir, CONFIG_FILENAME);
-  try {
-    await fs2.access(configPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/commands/generate.ts
-function mapPresetToTemplateId(preset) {
-  const presetLower = preset.toLowerCase();
-  if (presetLower.includes("clean") && presetLower.includes("dotnet")) {
-    return "clean-arch-dotnet";
-  }
-  if (presetLower.includes("clean") && (presetLower.includes("dart") || presetLower.includes("flutter"))) {
-    return "flutter-clean-dart-test";
-  }
-  if (presetLower.includes("clean") && presetLower.includes("typescript")) {
-    return "minimal-typescript-test";
-  }
-  if (presetLower.startsWith("clean-arch-")) {
-    return preset;
-  }
-  return null;
-}
-function mapPresetToTarget(preset) {
-  const presetLower = preset.toLowerCase();
-  if (presetLower.includes("dotnet") || presetLower.includes("aspnet") || presetLower.includes("csharp")) {
-    return "dotnet-entity";
-  }
-  if (presetLower.includes("dart") || presetLower.includes("flutter")) {
-    return "dart-entity";
-  }
-  if (presetLower.includes("typescript") || presetLower.includes("nextjs") || presetLower.includes("react")) {
-    return "typescript-interface";
-  }
-  return null;
+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";
 }
-function buildFeatureFlagsFromConfig(config) {
-  const flags = {
-    // Default all feature flags to true for full architecture
-    includeDtos: true,
-    includeUseCases: true,
-    includeMappers: true,
-    includeControllers: true,
-    includeEfConfig: true,
-    includeValidation: true,
-    includeDtoValidation: true,
-    // Data Annotations on Input records ([Required], [MaxLength], etc.)
-    // Test flags
-    includeUnitTests: true,
-    includeIntegrationTests: true,
-    // Starter files (disabled by default - user adds their own Program.cs)
-    includeStarterFiles: false
+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
   };
-  if (!config) return flags;
-  if (config.codeStyle?.includeValidations !== void 0) {
-    flags.includeValidation = config.codeStyle.includeValidations;
-  }
-  if (config.codeStyle?.includeTesting !== void 0) {
-    flags.includeUnitTests = config.codeStyle.includeTesting;
-    flags.includeIntegrationTests = config.codeStyle.includeTesting;
-  }
-  return flags;
-}
-async function generateCommand(options) {
-  const tokenManager = new TokenManager();
-  const token = await tokenManager.getAccessToken();
-  if (!token) {
-    console.log(chalk8.red("\n  Not authenticated"));
-    console.log(chalk8.gray("  Run 'aerocoding login' to get started\n"));
-    process.exit(1);
-  }
-  const config = await loadConfig();
-  const projectId = options.project || config?.project;
-  if (!projectId) {
-    console.log(chalk8.red("\n  Project ID required"));
-    console.log(chalk8.gray("  Run 'aerocoding init' to create a config file"));
-    console.log(chalk8.gray("  Or use --project <id> to specify a project\n"));
-    process.exit(1);
-  }
-  const output = options.output || config?.output || "./.aerocoding";
-  const validationLib = options.validationLib || config?.libraries?.validation;
-  const includeValidations = options.validations ?? config?.codeStyle?.includeValidations ?? true;
-  const includeComments = options.comments ?? config?.codeStyle?.includeComments ?? true;
-  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();
-  try {
-    const project = await apiClient.getProject(projectId);
-    spinner2.succeed(chalk8.gray("Project loaded"));
-    const hasBackendConfig = !!config?.backend?.preset;
-    const hasFrontendConfig = !!config?.frontend?.preset;
-    const hasBothTargets = hasBackendConfig && hasFrontendConfig;
-    let selectedTarget = "both";
-    if (hasBothTargets && !options.all) {
-      const targetChoice = await p.select({
-        message: "Which target do you want to generate?",
-        options: [
-          {
-            value: "backend",
-            label: `Backend (${config?.backend?.preset})`,
-            hint: "Recommended"
-          },
-          {
-            value: "frontend",
-            label: `Frontend (${config?.frontend?.preset})`
-          },
-          {
-            value: "both",
-            label: "Both"
-          }
-        ],
-        initialValue: "backend"
-      });
-      if (p.isCancel(targetChoice)) {
-        console.log(chalk8.yellow("\n  Generation cancelled\n"));
-        process.exit(0);
-      }
-      selectedTarget = targetChoice;
-    } else if (hasBackendConfig && !hasFrontendConfig) {
-      selectedTarget = "backend";
-    } else if (hasFrontendConfig && !hasBackendConfig) {
-      selectedTarget = "frontend";
-    }
-    const diagrams = project.schema?.diagrams || [];
-    const hasMultipleDiagrams = diagrams.length > 1;
-    let selectedDiagramIds = diagrams.map((d) => d.id || d.name || "unknown");
-    if (hasMultipleDiagrams && !options.all) {
-      const diagramChoices = await p.multiselect({
-        message: "Which bounded contexts do you want to generate?",
-        options: diagrams.map((d) => ({
-          value: d.id || d.name || "unknown",
-          label: `${d.name || "Unnamed"} (${d.entities?.length || 0} entities)`
-        })),
-        initialValues: diagrams.map((d) => d.id || d.name || "unknown"),
-        required: true
-      });
-      if (p.isCancel(diagramChoices)) {
-        console.log(chalk8.yellow("\n  Generation cancelled\n"));
-        process.exit(0);
-      }
-      selectedDiagramIds = diagramChoices;
+  for (const file of files) {
+    if (!isPathSafe(outputDir, file.path)) {
+      console.error(chalk6.red(`  Skipping unsafe path: ${file.path}`));
+      continue;
     }
-    let templateId = null;
-    let targets = [];
-    let backendPreset;
-    let frontendPreset;
-    if (selectedTarget === "backend" || selectedTarget === "both") {
-      backendPreset = options.backendPreset || config?.backend?.preset;
-      if (backendPreset) {
-        const tid = mapPresetToTemplateId(backendPreset);
-        if (tid) templateId = tid;
-        const target = mapPresetToTarget(backendPreset);
-        if (target) targets.push(target);
-      }
+    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 (selectedTarget === "frontend" || selectedTarget === "both") {
-      frontendPreset = options.frontendPreset || config?.frontend?.preset;
-      if (frontendPreset) {
-        const tid = mapPresetToTemplateId(frontendPreset);
-        if (tid && !templateId) templateId = tid;
-        const target = mapPresetToTarget(frontendPreset);
-        if (target) targets.push(target);
+    if (file.generateOnce && changeStatus.status !== "new") {
+      shouldWrite = false;
+      action = "skip";
+      if (!result.skipped.includes(file.path)) {
+        result.skipped.push(file.path);
       }
     }
-    if (!templateId && (!targets || targets.length === 0)) {
-      targets = options.targets || [];
-    }
-    const featureFlags = buildFeatureFlagsFromConfig(config);
-    spinner2 = 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;
-    let estimate = null;
-    try {
-      if (templateId) {
-        estimate = await apiClient.estimateCreditCost({
-          projectId,
-          templateId,
-          options: {
-            featureFlags,
-            useContexts,
-            diagramIds: estimateDiagramIds
+    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 (targets && targets.length > 0) {
-        estimate = await apiClient.estimateCreditCost({
-          projectId,
-          targets,
-          options: {
-            outputDir: output,
-            backendPreset,
-            frontendPreset,
-            useContexts,
-            diagramIds: estimateDiagramIds
+        } else if (isMerged) {
+          if (verbose) {
+            console.log(chalk6.magenta(`  \u2713 Merged  ${file.path}`));
           }
-        });
-      }
-    } catch {
-    }
-    spinner2.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"));
-      process.exit(1);
-    }
-    const hasEnoughCredits = estimate ? credits.remaining >= estimate.estimatedCredits : true;
-    console.log("");
-    console.log(chalk8.bold("  Generation Summary"));
-    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("  Project:"), chalk8.white(project.name));
-    if (config) {
-      console.log(chalk8.gray("  Config:"), chalk8.cyan(".aerocodingrc.json"));
-    }
-    if (templateId) {
-      console.log(chalk8.gray("  Mode:"), chalk8.green("Full Architecture"));
-      console.log(chalk8.gray("  Template:"), chalk8.cyan(templateId));
-    } else if (targets && targets.length > 0) {
-      console.log(chalk8.gray("  Mode:"), chalk8.yellow("Simple (legacy)"));
-      console.log(chalk8.gray("  Targets:"), chalk8.cyan(targets.join(", ")));
-    } else {
-      console.log(chalk8.gray("  Mode:"), chalk8.gray("default"));
-    }
-    if (hasBothTargets) {
-      const targetLabel = selectedTarget === "backend" ? "Backend only" : selectedTarget === "frontend" ? "Frontend only" : "Backend + Frontend";
-      console.log(chalk8.gray("  Target:"), chalk8.cyan(targetLabel));
-    }
-    if (backendPreset && (selectedTarget === "backend" || selectedTarget === "both")) {
-      console.log(chalk8.gray("  Backend Preset:"), chalk8.cyan(backendPreset));
-    }
-    if (frontendPreset && (selectedTarget === "frontend" || selectedTarget === "both")) {
-      console.log(chalk8.gray("  Frontend Preset:"), chalk8.cyan(frontendPreset));
-    }
-    if (hasMultipleDiagrams) {
-      const selectedCount = selectedDiagramIds.length;
-      const totalCount = diagrams.length;
-      if (selectedCount === totalCount) {
-        console.log(chalk8.gray("  Bounded Contexts:"), chalk8.cyan(`All (${totalCount})`));
-      } else {
-        const selectedNames = diagrams.filter((d) => selectedDiagramIds.includes(d.id || d.name || "unknown")).map((d) => d.name || "Unnamed").join(", ");
-        console.log(chalk8.gray("  Bounded Contexts:"), chalk8.cyan(`${selectedCount}/${totalCount} (${selectedNames})`));
-      }
-    }
-    const archStyle = config?.architectureStyle || "bounded-contexts";
-    console.log(
-      chalk8.gray("  Architecture:"),
-      archStyle === "bounded-contexts" ? chalk8.cyan("Bounded Contexts") : chalk8.yellow("Flat Structure")
-    );
-    const disabledOptions = [];
-    if (!includeValidations) disabledOptions.push("validations");
-    if (!includeComments) disabledOptions.push("comments");
-    if (!includeLogging) disabledOptions.push("logging");
-    if (!includeTesting) disabledOptions.push("testing");
-    if (disabledOptions.length > 0) {
-      console.log(chalk8.gray("  Disabled:"), chalk8.yellow(disabledOptions.join(", ")));
-    }
-    if (validationLib) {
-      console.log(chalk8.gray("  Validation Lib:"), chalk8.cyan(validationLib));
-    }
-    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`)
-        );
+        } 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}`));
       }
-      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));
+    } 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(chalk8.bold("  Credits"));
-    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"));
-    if (estimate) {
-      console.log(
-        chalk8.white("  Cost:"),
-        hasEnoughCredits ? chalk8.bold.yellow(`${estimate.estimatedCredits} credits`) : chalk8.bold.red(`${estimate.estimatedCredits} credits`)
-      );
-    }
-    console.log(
-      chalk8.white("  Available:"),
-      hasEnoughCredits ? chalk8.bold.green(`${credits.remaining} credits`) : chalk8.bold.red(`${credits.remaining} credits (insufficient)`)
-    );
-    console.log("");
-    if (!hasEnoughCredits && estimate) {
-      console.log(chalk8.red("  \u26A0 Not enough credits for this generation."));
-      console.log(chalk8.gray(`  Need ${estimate.estimatedCredits - credits.remaining} more credits.
-`));
-      process.exit(1);
-    }
-    if (!options.yes) {
-      const confirmed = await promptConfirm("  Proceed with generation?");
-      if (!confirmed) {
-        console.log(chalk8.yellow("\n  Generation cancelled\n"));
-        process.exit(0);
-      }
-    }
+    console.log(chalk6.yellow("  \u26A0 Conflicts need manual resolution:"));
     console.log("");
-    spinner2 = 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
-      projectId,
-      templateId,
-      options: {
-        includeValidations,
-        includeComments,
-        featureFlags,
-        useContexts,
-        diagramIds
-        // Filter by selected bounded contexts
+    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}`));
       }
-    } : {
-      // Legacy mode using targets
-      projectId,
-      targets,
-      options: {
-        includeValidations,
-        includeComments,
-        includeLogging,
-        includeTesting,
-        outputDir: output,
-        backendPreset,
-        frontendPreset,
-        validationLib,
-        useContexts,
-        diagramIds
-        // Filter by selected bounded contexts
+      if (conflict.conflictPath) {
+        console.log(chalk6.gray(`      \u2192 ${conflict.conflictPath}`));
       }
-    };
-    const result = await apiClient.generateCode(generatePayload);
-    spinner2.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"));
-    console.log(chalk8.gray("  Files:"), chalk8.cyan(result.stats?.totalFiles ?? result.files?.length ?? 0));
-    if (result.stats?.totalEntities) {
-      console.log(chalk8.gray("  Entities:"), chalk8.cyan(result.stats.totalEntities));
-    }
-    if (result.stats?.languages && result.stats.languages.length > 0) {
-      console.log(
-        chalk8.gray("  Languages:"),
-        chalk8.cyan(result.stats.languages.join(", "))
-      );
     }
-    if (result.creditsUsed !== void 0) {
-      console.log("");
-      console.log(chalk8.bold("  Credits"));
-      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("  Used:"), chalk8.yellow(result.creditsUsed));
-      console.log(
-        chalk8.gray("  Remaining:"),
-        result.creditsRemaining !== void 0 && result.creditsRemaining > 50 ? chalk8.green(result.creditsRemaining) : chalk8.yellow(result.creditsRemaining)
-      );
-    }
-    if (result.warnings && result.warnings.length > 0) {
-      console.log("");
-      console.log(chalk8.yellow("  Warnings:"));
-      for (const warning of result.warnings) {
-        console.log(chalk8.yellow(`    - ${warning}`));
-      }
+    if (result.conflicts.length > 5) {
+      console.log(chalk6.gray(`    ... and ${result.conflicts.length - 5} more`));
     }
     console.log("");
-    await writeGeneratedFiles(result.files, output, options.verbose);
-    console.log(chalk8.green(`  Files written to ${chalk8.white(output)}`));
-    console.log("");
-  } catch (error) {
-    spinner2.fail(chalk8.red("Generation failed"));
-    if (error.response?.status === 401) {
-      await handleUnauthorized(tokenManager);
-    } else if (error.response?.status === 403) {
-      console.log(chalk8.yellow("\n  You don't have permission to access this project."));
-      console.log(chalk8.gray("  Check if you're part of the organization.\n"));
-    } else if (error.response?.status === 404) {
-      console.log(chalk8.yellow("\n  Project not found."));
-      console.log(chalk8.gray("  Check if the project ID is correct.\n"));
-    } else if (error.response?.status === 429) {
-      const data = error.response.data;
-      console.log(chalk8.red("\n  Insufficient credits"));
-      if (data.requiredCredits) {
-        console.log(chalk8.yellow(`  Required: ${data.requiredCredits} credits`));
-      }
-      console.log(chalk8.yellow(`  Available: ${data.remaining ?? 0} credits`));
-      console.log(chalk8.gray("\n  Upgrade your plan or wait for credit reset.\n"));
-    } else if (error.response?.data?.message) {
-      console.log(chalk8.red(`
-  ${error.response.data.message}
-`));
-    } else {
-      console.log(chalk8.red(`
-  ${error.message}
-`));
-    }
-    process.exit(1);
+    console.log(chalk6.gray("  Run 'aerocoding resolve' after fixing conflicts."));
   }
 }
 
-// src/commands/init.ts
-import * as p2 from "@clack/prompts";
-import chalk9 from "chalk";
-async function initCommand(options) {
-  p2.intro(chalk9.bgCyan.black(" AeroCoding CLI "));
-  if (!options.force && await configExists()) {
-    const overwrite = await p2.confirm({
-      message: "Config file already exists. Overwrite?",
-      initialValue: false
-    });
-    if (p2.isCancel(overwrite) || !overwrite) {
-      p2.cancel("Operation cancelled.");
-      process.exit(0);
+// src/config/project-config.ts
+import { z } 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 = z.object({
+  $schema: z.string().optional().default("https://aerocoding.dev/schema.json"),
+  /** Project UUID from aerocoding.dev */
+  projectId: z.string().uuid(),
+  /** Template ID for architecture generation */
+  templateId: z.string().min(1),
+  /** Template version at project creation */
+  templateVersion: z.string().optional(),
+  /** Root namespace/package name */
+  namespace: z.string().min(1),
+  /** Output directories */
+  output: z.object({
+    backend: z.string().default("./backend"),
+    frontend: z.string().default("./frontend")
+  }).optional().default({ backend: "./backend", frontend: "./frontend" }),
+  /** Organization ID (for cloud sync) */
+  organizationId: z.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) {
+  p.intro(chalk7.bgCyan.black(" AeroCoding Create "));
   const tokenManager = new TokenManager();
   const token = await tokenManager.getAccessToken();
   if (!token) {
-    p2.cancel("Not logged in. Run 'aerocoding login' first.");
+    p.cancel("Not logged in. Run 'aerocoding login' first.");
     process.exit(1);
   }
   const apiClient = createApiClientWithAutoLogout(token, tokenManager);
   try {
-    const orgSpinner = p2.spinner();
+    const orgSpinner = p.spinner();
     orgSpinner.start("Loading organizations...");
     const organizations = await apiClient.listOrganizations();
     orgSpinner.stop("Organizations loaded");
     if (organizations.length === 0) {
-      p2.cancel("No organizations found. Create one on aerocoding.dev first.");
+      p.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;
-      p2.log.info(`Organization: ${organizations[0].name}`);
+      p.log.info(`Organization: ${organizations[0].name}`);
     } else {
-      const selectedOrg = await p2.select({
+      const selectedOrg = await p.select({
         message: "Select organization",
         options: organizations.map((org) => ({
           value: org.id,
@@ -1170,221 +1261,634 @@ async function initCommand(options) {
           hint: org.planTier.toUpperCase()
         }))
       });
-      if (p2.isCancel(selectedOrg)) {
-        p2.cancel("Operation cancelled.");
+      if (p.isCancel(selectedOrg)) {
+        p.cancel("Operation cancelled.");
         process.exit(0);
       }
       organizationId = selectedOrg;
     }
     let projectId = options.project;
     if (!projectId) {
-      const spinner3 = p2.spinner();
-      spinner3.start("Loading projects...");
+      const spinner4 = p.spinner();
+      spinner4.start("Loading projects...");
       const projects = await apiClient.listProjects(organizationId);
-      spinner3.stop("Projects loaded");
+      spinner4.stop("Projects loaded");
       if (projects.length === 0) {
-        p2.cancel("No projects in this organization. Create one on aerocoding.dev first.");
+        p.cancel("No projects in this organization. Create one on aerocoding.dev first.");
         process.exit(1);
       }
-      const selectedProject = await p2.select({
-        message: "Select project",
+      const selectedProject = await p.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 (p2.isCancel(selectedProject)) {
-        p2.cancel("Operation cancelled.");
+      if (p.isCancel(selectedProject)) {
+        p.cancel("Operation cancelled.");
         process.exit(0);
       }
       projectId = selectedProject;
     }
-    const spinner2 = p2.spinner();
-    spinner2.start("Fetching project details...");
+    const projectSpinner = p.spinner();
+    projectSpinner.start("Fetching project details...");
     const project = await apiClient.getProject(projectId);
-    spinner2.stop(`Project: ${project.name}`);
-    const hasBackend = !!project.backendFramework;
-    const hasFrontend = !!project.frontendFramework;
-    if (!hasBackend && !hasFrontend) {
-      p2.cancel("Project has no frameworks configured. Update it on aerocoding.dev first.");
+    projectSpinner.stop(`Project: ${project.name}`);
+    const dirName = projectName || project.name;
+    const safeName = dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (!safeName) {
+      p.cancel("Invalid project name. Use alphanumeric characters and hyphens.");
       process.exit(1);
     }
-    if (hasBackend) {
-      p2.log.success(`Backend: ${project.backendFramework?.toUpperCase()} detected`);
-    }
-    if (hasFrontend) {
-      p2.log.success(`Frontend: ${project.frontendFramework?.toUpperCase()} detected`);
-    }
-    const config = {
-      project: projectId,
-      output: "./.aerocoding",
-      architectureStyle: "flat",
-      // Default, will be updated based on template or user choice
-      codeStyle: {
-        includeValidations: true,
-        includeComments: true,
-        includeLogging: true,
-        includeTesting: true
-      }
-    };
-    let selectedBackendTemplate = null;
-    let selectedFrontendTemplate = null;
-    if (hasBackend && project.backendFramework) {
-      const archSpinner = p2.spinner();
-      archSpinner.start("Loading backend templates...");
-      const templateResult = await apiClient.getTemplates({
-        category: "backend",
-        language: project.backendFramework
-      });
-      archSpinner.stop("Templates loaded");
-      if (templateResult.templates.length > 0) {
-        const preset = await p2.select({
-          message: "Backend template",
-          options: templateResult.templates.map((tmpl) => ({
-            value: tmpl.id,
-            label: tmpl.name,
-            hint: tmpl.description || `${tmpl.tier} tier`
-          }))
+    const projectDir = resolve(process.cwd(), safeName);
+    try {
+      await access3(projectDir);
+      if (!options.force) {
+        const overwrite = await p.confirm({
+          message: `Directory '${safeName}' already exists. Overwrite?`,
+          initialValue: false
         });
-        if (p2.isCancel(preset)) {
-          p2.cancel("Operation cancelled.");
+        if (p.isCancel(overwrite) || !overwrite) {
+          p.cancel("Operation cancelled.");
           process.exit(0);
         }
-        const fullTemplate = await apiClient.getTemplate(preset);
-        selectedBackendTemplate = fullTemplate;
-        config.backend = {
-          preset
-        };
       }
+    } catch {
     }
-    if (hasFrontend && project.frontendFramework) {
-      const archSpinner = p2.spinner();
-      archSpinner.start("Loading frontend templates...");
+    let templateId = options.template;
+    if (!templateId) {
+      const templateSpinner = p.spinner();
+      templateSpinner.start("Loading templates...");
       const templateResult = await apiClient.getTemplates({
-        category: "frontend",
-        framework: project.frontendFramework
+        category: "backend",
+        language: project.backendFramework || void 0
       });
-      archSpinner.stop("Templates loaded");
-      if (templateResult.templates.length > 0) {
-        const preset = await p2.select({
-          message: "Frontend template",
-          options: templateResult.templates.map((tmpl) => ({
-            value: tmpl.id,
-            label: tmpl.name,
-            hint: tmpl.description || `${tmpl.tier} tier`
-          }))
-        });
-        if (p2.isCancel(preset)) {
-          p2.cancel("Operation cancelled.");
-          process.exit(0);
-        }
-        const fullTemplate = await apiClient.getTemplate(preset);
-        selectedFrontendTemplate = fullTemplate;
-        config.frontend = {
-          preset
-        };
+      templateSpinner.stop("Templates loaded");
+      if (templateResult.templates.length === 0) {
+        p.cancel("No templates available for this project's framework.");
+        process.exit(1);
       }
+      const selectedTemplate = await p.select({
+        message: "Select architecture template",
+        options: templateResult.templates.map((tmpl) => ({
+          value: tmpl.id,
+          label: tmpl.name,
+          hint: tmpl.description || `${tmpl.tier} tier`
+        }))
+      });
+      if (p.isCancel(selectedTemplate)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      templateId = selectedTemplate;
     }
-    const templateArchStyle = selectedBackendTemplate?.architectureStyle || selectedFrontendTemplate?.architectureStyle;
-    const recommendedStyle = templateArchStyle || "flat";
-    const architectureStyle = await p2.select({
-      message: "How would you like to organize your code?",
-      options: [
-        {
-          value: "bounded-contexts",
-          label: recommendedStyle === "bounded-contexts" ? "Bounded Contexts (Recommended)" : "Bounded Contexts",
-          hint: "Each module has its own Domain, Application, Infrastructure"
-        },
-        {
-          value: "flat",
-          label: recommendedStyle === "flat" ? "Flat Structure (Recommended)" : "Flat Structure",
-          hint: "Single Domain, Application, Infrastructure for the entire project"
+    const namespace = await p.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";
         }
-      ],
-      initialValue: recommendedStyle
+        return void 0;
+      }
     });
-    if (p2.isCancel(architectureStyle)) {
-      p2.cancel("Operation cancelled.");
+    if (p.isCancel(namespace)) {
+      p.cancel("Operation cancelled.");
       process.exit(0);
     }
-    config.architectureStyle = architectureStyle;
-    const codeStyleOptions = await p2.multiselect({
-      message: "Code style options",
-      options: [
-        { value: "validations", label: "Include validations (Recommended)", hint: "Add validation rules" },
-        { value: "comments", label: "Include comments (Recommended)", hint: "Add code documentation" },
-        { value: "logging", label: "Include logging (Recommended)", hint: "Add log statements" },
-        { value: "testing", label: "Include tests (Recommended)", hint: "Generate test files" }
-      ],
-      initialValues: ["validations", "comments", "logging", "testing"]
+    p.log.step(chalk7.bold("Configuration Summary:"));
+    p.log.info(`  Directory: ${safeName}/`);
+    p.log.info(`  Project: ${project.name}`);
+    p.log.info(`  Template: ${templateId}`);
+    p.log.info(`  Namespace: ${namespace}`);
+    const proceed = await p.confirm({
+      message: "Create project with these settings?",
+      initialValue: true
     });
-    if (p2.isCancel(codeStyleOptions)) {
-      p2.cancel("Operation cancelled.");
+    if (p.isCancel(proceed) || !proceed) {
+      p.cancel("Operation cancelled.");
       process.exit(0);
     }
-    const selectedStyles = codeStyleOptions;
-    config.codeStyle = {
-      includeValidations: selectedStyles.includes("validations"),
-      includeComments: selectedStyles.includes("comments"),
-      includeLogging: selectedStyles.includes("logging"),
-      includeTesting: selectedStyles.includes("testing")
-    };
-    config.output = "./.aerocoding";
-    p2.log.step(chalk9.bold("Configuration Summary:"));
-    if (config.backend) {
-      p2.log.info(`  Backend: ${config.backend.preset}`);
+    const dirSpinner = p.spinner();
+    dirSpinner.start(`Creating ${safeName}/...`);
+    await mkdir(projectDir, { recursive: true });
+    dirSpinner.stop(`Created ${safeName}/`);
+    const genSpinner = ora2({ 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(chalk7.green(`Generated ${result.files?.length || 0} files`));
+    const writeSpinner = p.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 = p.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)
+      });
     }
-    if (config.frontend) {
-      p2.log.info(`  Frontend: ${config.frontend.preset}`);
+    await writeManifest(projectDir, manifest);
+    configSpinner.stop("Config files created");
+    try {
+      const syncResult = await syncToCloud(apiClient, projectId, manifest);
+      if (syncResult.success) {
+        console.log(
+          chalk7.gray("  \u2713 Manifest synced to cloud") + chalk7.gray(` (${syncResult.fileCount} files)`)
+        );
+      }
+    } catch {
+      console.log(chalk7.yellow("  \u26A0 Could not sync manifest to cloud"));
     }
-    p2.log.info(
-      `  Architecture: ${config.architectureStyle === "bounded-contexts" ? "Bounded Contexts" : "Flat Structure"}`
-    );
-    p2.log.info(`  Output: ${config.output}`);
-    await saveConfig(config);
-    p2.outro(
-      chalk9.green("Config saved to .aerocodingrc.json") + "\n\n" + chalk9.gray("  Run ") + chalk9.cyan("aerocoding generate") + chalk9.gray(" to generate code!")
+    console.log("");
+    console.log(chalk7.bold("  Project Created Successfully!"));
+    console.log(chalk7.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(chalk7.gray("  Directory:"), chalk7.cyan(safeName + "/"));
+    console.log(chalk7.gray("  Files:"), chalk7.cyan(organizedFiles.length));
+    console.log(chalk7.gray("  Config:"), chalk7.cyan(PROJECT_CONFIG_FILENAME));
+    console.log(chalk7.gray("  Manifest:"), chalk7.cyan(MANIFEST_FILENAME));
+    if (result.creditsUsed !== void 0) {
+      console.log("");
+      console.log(chalk7.gray("  Credits used:"), chalk7.yellow(result.creditsUsed));
+      console.log(chalk7.gray("  Credits remaining:"), chalk7.green(result.creditsRemaining));
+    }
+    p.outro(
+      chalk7.green("Project ready!") + "\n\n" + chalk7.gray("  Next steps:\n") + chalk7.cyan(`    cd ${safeName}
+`) + chalk7.gray("    # Make changes in the diagram editor\n") + chalk7.cyan("    aerocoding update") + chalk7.gray("  # Sync changes incrementally")
     );
   } catch (error) {
-    if (error.response?.status === 401) {
+    const err = error;
+    if (err.response?.status === 401) {
       await handleUnauthorized(tokenManager);
-    } else if (error.response?.data?.message) {
-      p2.cancel(error.response.data.message);
+    } else if (err.response?.data?.message) {
+      p.cancel(err.response.data.message);
     } else {
-      p2.cancel(error.message || "An unexpected error occurred");
+      p.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/pull.ts
-import chalk10 from "chalk";
-async function pullCommand(options) {
-  console.log(chalk10.yellow("Command not yet implemented"));
-  if (options.project) {
-    console.log(chalk10.gray(`  Requested project: ${options.project}`));
-  }
-  console.log(chalk10.gray("  Coming soon in v0.2.0\n"));
+// src/commands/update.ts
+import * as p2 from "@clack/prompts";
+import chalk8 from "chalk";
+import ora3 from "ora";
+async function updateCommand(options) {
+  p2.intro(chalk8.bgCyan.black(" AeroCoding Update "));
+  const config = await loadProjectConfig();
+  if (!config) {
+    p2.cancel(
+      `No ${PROJECT_CONFIG_FILENAME} found. Run 'aerocoding create' first.`
+    );
+    process.exit(1);
+  }
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    p2.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) {
+      p2.log.info(
+        `Found manifest with ${fileCount} tracked files (last sync: ${manifest.lastSync || "unknown"})`
+      );
+    } else {
+      p2.log.warn("No local manifest found.");
+      const cloudCheck = await compareWithCloud(apiClient, config.projectId, null);
+      if (cloudCheck.hasCloudBackup) {
+        p2.log.info(
+          chalk8.cyan(
+            `  Cloud backup available (${cloudCheck.cloudFileCount} files, synced ${formatSyncDate(cloudCheck.cloudLastSync)})`
+          )
+        );
+        const recovery = await p2.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 (p2.isCancel(recovery) || recovery === "cancel") {
+          p2.cancel("Update cancelled.");
+          process.exit(0);
+        }
+        if (recovery === "restore") {
+          const restoreSpinner = p2.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(
+              chalk8.green(`Restored ${fileCount} files from cloud backup`)
+            );
+          } else {
+            restoreSpinner.stop(chalk8.yellow("Cloud backup not found"));
+          }
+        }
+      } else {
+        p2.log.info(
+          chalk8.gray("  No cloud backup available. All generated files will be created as new.")
+        );
+      }
+    }
+    const projectSpinner = p2.spinner();
+    projectSpinner.start("Fetching project details...");
+    const project = await apiClient.getProject(config.projectId);
+    projectSpinner.stop(`Project: ${project.name}`);
+    p2.log.step(chalk8.bold("Update Configuration:"));
+    p2.log.info(`  Project: ${project.name}`);
+    p2.log.info(`  Template: ${config.templateId}`);
+    p2.log.info(`  Namespace: ${config.namespace}`);
+    p2.log.info(`  Output: ${config.output.backend}`);
+    if (options.dryRun) {
+      p2.log.info(chalk8.yellow("  Mode: DRY RUN (no files will be written)"));
+    }
+    if (options.force) {
+      p2.log.info(chalk8.yellow("  Mode: FORCE (will overwrite modified files)"));
+    }
+    if (!options.dryRun) {
+      const proceed = await p2.confirm({
+        message: "Proceed with update?",
+        initialValue: true
+      });
+      if (p2.isCancel(proceed) || !proceed) {
+        p2.cancel("Update cancelled.");
+        process.exit(0);
+      }
+    }
+    const genSpinner = ora3({
+      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(
+      chalk8.green(`Generated ${result.files?.length || 0} files from schema`)
+    );
+    if (options.dryRun) {
+      p2.log.info("");
+      p2.log.info(chalk8.bold("  Dry Run Results:"));
+      p2.log.info(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"));
+      p2.log.info(`  Files to process: ${result.files?.length || 0}`);
+      p2.log.info(`  Tracked files: ${fileCount}`);
+      p2.log.info("");
+      p2.log.info(chalk8.gray("  Run without --dry-run to apply changes."));
+      p2.outro(chalk8.green("Dry run complete!"));
+      return;
+    }
+    const updateSpinner = p2.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(chalk8.gray("  Credits used:"), chalk8.yellow(result.creditsUsed));
+      console.log(
+        chalk8.gray("  Credits remaining:"),
+        chalk8.green(result.creditsRemaining)
+      );
+    }
+    try {
+      const syncResult = await syncToCloud(
+        apiClient,
+        config.projectId,
+        writeResult.manifest
+      );
+      if (syncResult.success) {
+        console.log(
+          chalk8.gray("  \u2713 Manifest synced to cloud") + chalk8.gray(` (${syncResult.fileCount} files)`)
+        );
+      }
+    } catch (syncError) {
+      console.log(chalk8.yellow("  \u26A0 Could not sync manifest to cloud"));
+      if (options.verbose) {
+        console.log(chalk8.gray(`    ${syncError.message}`));
+      }
+    }
+    if (writeResult.conflicts.length > 0) {
+      p2.outro(
+        chalk8.yellow(`Update complete with ${writeResult.conflicts.length} conflict(s).`) + "\n" + chalk8.gray("  Run 'aerocoding resolve' after fixing conflicts.")
+      );
+    } else {
+      const totalWritten = writeResult.created.length + writeResult.updated.length + writeResult.merged.length;
+      p2.outro(
+        chalk8.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) {
+      p2.cancel(err.response.data.message);
+    } else {
+      p2.cancel(err.message || "An unexpected error occurred");
+    }
+    process.exit(1);
+  }
 }
 
-// src/commands/status.ts
-import chalk11 from "chalk";
-async function statusCommand() {
-  console.log(chalk11.yellow("Command not yet implemented"));
-  console.log(chalk11.gray("  Coming soon in v0.2.0\n"));
+// src/commands/resolve.ts
+import * as p3 from "@clack/prompts";
+import chalk9 from "chalk";
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3, relative } from "path";
+async function resolveCommand(options) {
+  p3.intro(chalk9.bgCyan.black(" AeroCoding Resolve "));
+  const config = await loadProjectConfig();
+  if (!config) {
+    p3.cancel(
+      `No ${PROJECT_CONFIG_FILENAME} found. Run 'aerocoding create' first.`
+    );
+    process.exit(1);
+  }
+  const spinner4 = p3.spinner();
+  spinner4.start("Scanning for conflict files...");
+  const conflicts = await findConflictFiles(process.cwd());
+  spinner4.stop(`Found ${conflicts.length} conflict(s)`);
+  if (conflicts.length === 0) {
+    p3.log.success("No conflicts to resolve!");
+    p3.outro(chalk9.green("All clear!"));
+    return;
+  }
+  p3.log.info("");
+  p3.log.info(chalk9.bold("  Pending Conflicts:"));
+  p3.log.info(chalk9.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);
+    p3.log.info(chalk9.yellow(`  \u26A0 ${relPath}`));
+    if (options.verbose) {
+      p3.log.info(chalk9.gray(`      \u2192 ${relative(process.cwd(), conflict.newPath)}`));
+      p3.log.info(
+        chalk9.gray(`      \u2192 ${relative(process.cwd(), conflict.conflictPath)}`)
+      );
+    }
+  }
+  p3.log.info(chalk9.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"));
+  p3.log.info("");
+  if (!options.all) {
+    const proceed = await p3.confirm({
+      message: `Remove ${conflicts.length} conflict file(s)? (This assumes you've resolved them)`,
+      initialValue: true
+    });
+    if (p3.isCancel(proceed) || !proceed) {
+      p3.cancel("Resolution cancelled.");
+      process.exit(0);
+    }
+  }
+  let manifest = await readManifest(process.cwd());
+  if (!manifest) {
+    p3.cancel("No manifest found. Cannot update file hashes.");
+    process.exit(1);
+  }
+  const resolveSpinner = p3.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(
+            chalk9.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(
+          chalk9.green(`  \u2713 ${relPath}`) + chalk9.gray(` (removed ${removed.join(", ")})`)
+        );
+      }
+      resolved++;
+    } catch (error) {
+      failed++;
+      if (options.verbose) {
+        const relPath = relative(process.cwd(), conflict.originalPath);
+        console.log(chalk9.red(`  \u2717 ${relPath} - ${error}`));
+      }
+    }
+  }
+  manifest = {
+    ...manifest,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeManifest(process.cwd(), manifest);
+  resolveSpinner.stop("Conflicts resolved");
+  console.log("");
+  console.log(chalk9.bold("  Resolution Results"));
+  console.log(chalk9.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(chalk9.green(`  \u2713 Resolved: ${resolved} files`));
+  }
+  if (failed > 0) {
+    console.log(chalk9.red(`  \u2717 Failed:   ${failed} files`));
+  }
+  console.log(chalk9.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) {
+    p3.outro(
+      chalk9.yellow(
+        `Resolved ${resolved} conflict(s), ${failed} failed.`
+      )
+    );
+  } else {
+    p3.outro(chalk9.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/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.25");
 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("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);
+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.parse();
 //# sourceMappingURL=index.js.map