aerocoding 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1034 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import chalk4 from "chalk";
+
+// src/auth/device-flow.ts
+import axios from "axios";
+import chalk from "chalk";
+import ora from "ora";
+import open from "open";
+var API_URL = process.env.API_URL || "http://localhost:3000";
+var MAX_POLL_TIME = 15 * 60 * 1e3;
+var DeviceFlow = class {
+  /**
+   * Initiate the complete device authorization flow
+   */
+  async initiateAuth() {
+    const deviceAuth = await this.requestDeviceCode();
+    this.displayUserCode(deviceAuth);
+    await this.openBrowser(deviceAuth.verification_uri_complete);
+    const tokens = await this.pollForToken(deviceAuth);
+    return tokens;
+  }
+  /**
+   * Step 1: Request device code from server
+   */
+  async requestDeviceCode() {
+    try {
+      const response = await axios.post(`${API_URL}/api/device/authorize`, {
+        client_id: "aerocoding-cli",
+        scope: "generate:code projects:read"
+      });
+      return response.data;
+    } catch (error) {
+      console.error(chalk.red("Failed to initiate device authorization"));
+      if (error.response) {
+        console.error(
+          chalk.red(`Error: ${error.response.data.error_description}`)
+        );
+      }
+      throw new Error("Failed to initiate device authorization");
+    }
+  }
+  /**
+   * Step 2: Display user code and instructions
+   */
+  displayUserCode(auth) {
+    console.log("\n");
+    console.log(chalk.cyan("\u2501".repeat(60)));
+    console.log(chalk.bold.white("  \u{1F680} AeroCoding CLI - Device Activation"));
+    console.log(chalk.cyan("\u2501".repeat(60)));
+    console.log("");
+    console.log(chalk.white("  1. Open this URL in your browser:"));
+    console.log(chalk.cyan.bold(`     ${auth.verification_uri}`));
+    console.log("");
+    console.log(chalk.white("  2. Enter this code:"));
+    console.log(chalk.green.bold(`     ${auth.user_code}`));
+    console.log("");
+    console.log(chalk.white("  3. Confirm you see this code on the website:"));
+    console.log(chalk.yellow.bold(`     ${auth.confirmation_code}`));
+    console.log("");
+    console.log(
+      chalk.gray(`  Code expires in ${auth.expires_in / 60} minutes`)
+    );
+    console.log(chalk.cyan("\u2501".repeat(60)));
+    console.log("");
+  }
+  /**
+   * Step 2.5: Open browser automatically
+   */
+  async openBrowser(url) {
+    try {
+      await open(url);
+      console.log(chalk.gray("  \u2713 Opening browser..."));
+    } catch {
+      console.log(chalk.yellow("  \u26A0 Could not open browser automatically"));
+      console.log(chalk.gray("    Please open the URL manually\n"));
+    }
+  }
+  /**
+   * Step 3: Poll for token
+   */
+  async pollForToken(auth) {
+    const spinner2 = ora({
+      text: "Waiting for authorization...",
+      color: "cyan"
+    }).start();
+    const startTime = Date.now();
+    let currentInterval = auth.interval * 1e3;
+    while (true) {
+      if (Date.now() - startTime > MAX_POLL_TIME) {
+        spinner2.fail(chalk.red("Authorization timeout"));
+        throw new Error("Device authorization timed out");
+      }
+      try {
+        const response = await axios.post(`${API_URL}/api/device/token`, {
+          device_code: auth.device_code,
+          client_id: "aerocoding-cli"
+        });
+        spinner2.succeed(chalk.green("\u2713 Successfully authenticated!"));
+        return response.data;
+      } catch (error) {
+        const errorCode = error.response?.data?.error;
+        const errorDescription = error.response?.data?.error_description;
+        if (errorCode === "authorization_pending") {
+          await this.sleep(currentInterval);
+          continue;
+        }
+        if (errorCode === "slow_down") {
+          currentInterval += 5e3;
+          spinner2.text = "Polling... (slowed down to avoid spam)";
+          await this.sleep(currentInterval);
+          continue;
+        }
+        if (errorCode === "expired_token") {
+          spinner2.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"));
+          throw new Error("You denied the authorization request");
+        }
+        spinner2.fail(chalk.red("Authorization failed"));
+        console.error(
+          chalk.red(`Error: ${errorDescription || "Unknown error"}`)
+        );
+        throw new Error(errorDescription || "Unknown error");
+      }
+    }
+  }
+  /**
+   * Helper: Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/auth/token-manager.ts
+import { Entry } from "@napi-rs/keyring";
+import { createClient } from "@supabase/supabase-js";
+import chalk2 from "chalk";
+var SERVICE_NAME = "aerocoding-cli";
+var SUPABASE_URL = process.env.SUPABASE_URL || "https://your-project.supabase.co";
+var SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || "";
+function getPassword(service, account) {
+  try {
+    const entry = new Entry(service, account);
+    return entry.getPassword();
+  } catch {
+    return null;
+  }
+}
+function setPassword(service, account, password) {
+  const entry = new Entry(service, account);
+  entry.setPassword(password);
+}
+function deletePassword(service, account) {
+  try {
+    const entry = new Entry(service, account);
+    entry.deletePassword();
+  } catch {
+  }
+}
+var TokenManager = class {
+  supabase;
+  constructor() {
+    this.supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+      auth: {
+        autoRefreshToken: false,
+        persistSession: false
+      }
+    });
+  }
+  /**
+   * Get access token, automatically refreshing if expired
+   */
+  async getAccessToken() {
+    try {
+      let accessToken = getPassword(SERVICE_NAME, "access_token");
+      if (!accessToken) {
+        return null;
+      }
+      if (this.isTokenExpired(accessToken)) {
+        console.log(chalk2.yellow("\u23F1\uFE0F  Token expired, refreshing..."));
+        accessToken = await this.refreshTokens();
+      }
+      return accessToken;
+    } catch (error) {
+      console.error(chalk2.red("Failed to get access token:"), error);
+      return null;
+    }
+  }
+  /**
+   * Refresh tokens using stored refresh token
+   */
+  async refreshTokens() {
+    try {
+      const refreshToken = getPassword(SERVICE_NAME, "refresh_token");
+      if (!refreshToken) {
+        throw new Error("No refresh token available");
+      }
+      const { data, error } = await this.supabase.auth.refreshSession({
+        refresh_token: refreshToken
+      });
+      if (error || !data.session) {
+        throw new Error("Failed to refresh session");
+      }
+      setPassword(SERVICE_NAME, "access_token", data.session.access_token);
+      setPassword(SERVICE_NAME, "refresh_token", data.session.refresh_token);
+      console.log(chalk2.green("\u2713 Token refreshed successfully"));
+      return data.session.access_token;
+    } catch (error) {
+      console.error(chalk2.red("Token refresh failed. Please login again."));
+      await this.logout();
+      throw error;
+    }
+  }
+  /**
+   * Check if JWT token is expired (or expires in < 5 min)
+   */
+  isTokenExpired(token) {
+    try {
+      const payload = JSON.parse(
+        Buffer.from(token.split(".")[1], "base64").toString()
+      );
+      const expiresAt = payload.exp * 1e3;
+      const now = Date.now();
+      return expiresAt - now < 5 * 60 * 1e3;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Save tokens and user metadata after successful login
+   */
+  async saveTokens(accessToken, refreshToken, user) {
+    try {
+      setPassword(SERVICE_NAME, "access_token", accessToken);
+      setPassword(SERVICE_NAME, "refresh_token", refreshToken);
+      setPassword(SERVICE_NAME, "user_metadata", JSON.stringify(user));
+    } catch (error) {
+      console.error(chalk2.red("Failed to save tokens:"), error);
+      throw error;
+    }
+  }
+  /**
+   * Get stored user metadata
+   */
+  async getUserMetadata() {
+    try {
+      const metadata = getPassword(SERVICE_NAME, "user_metadata");
+      return metadata ? JSON.parse(metadata) : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Logout - clear all stored credentials
+   */
+  async logout() {
+    try {
+      deletePassword(SERVICE_NAME, "access_token");
+      deletePassword(SERVICE_NAME, "refresh_token");
+      deletePassword(SERVICE_NAME, "user_metadata");
+    } catch (error) {
+    }
+  }
+  /**
+   * Check if user is currently authenticated
+   */
+  async isAuthenticated() {
+    const token = await this.getAccessToken();
+    return token !== null;
+  }
+};
+
+// src/api/client.ts
+import axios2 from "axios";
+var API_URL2 = process.env.API_URL || "http://localhost:3000";
+var ApiClient = class {
+  client;
+  constructor(accessToken, options) {
+    this.client = axios2.create({
+      baseURL: API_URL2,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 3e4
+      // 30 seconds
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error?.response?.status === 401) {
+          await options?.onUnauthorized?.();
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  /**
+   * Get current authenticated user
+   */
+  async getCurrentUser() {
+    const response = await this.client.get("/api/user/me");
+    return response.data;
+  }
+  /**
+   * List user's projects
+   */
+  async listProjects(organizationId) {
+    const response = await this.client.get("/api/projects", {
+      params: { organizationId }
+    });
+    return response.data;
+  }
+  /**
+   * Get project by ID
+   */
+  async getProject(projectId) {
+    const response = await this.client.get(`/api/projects/${projectId}`);
+    return response.data;
+  }
+  /**
+   * Generate code from project schema
+   */
+  async generateCode(payload) {
+    const response = await this.client.post("/api/generate", payload);
+    return response.data.data;
+  }
+  /**
+   * Get credit usage for organization
+   */
+  async getCreditUsage(organizationId) {
+    const response = await this.client.get("/api/credits/usage", {
+      params: { organizationId }
+    });
+    return response.data;
+  }
+  /**
+   * Get available architectures for a framework
+   */
+  async getArchitectures(framework) {
+    const response = await this.client.get("/api/architectures", {
+      params: { framework }
+    });
+    return response.data;
+  }
+};
+
+// src/commands/_shared/create-api-client.ts
+function createApiClientWithAutoLogout(accessToken, tokenManager) {
+  return new ApiClient(accessToken, {
+    onUnauthorized: async () => {
+      await tokenManager.logout();
+    }
+  });
+}
+
+// src/commands/_shared/unauthorized.ts
+import chalk3 from "chalk";
+async function handleUnauthorized(tokenManager) {
+  await tokenManager.logout();
+  console.error(
+    chalk3.yellow(
+      "  Your session is invalid or expired. You have been logged out."
+    )
+  );
+  console.error(chalk3.gray("  Run 'aerocoding login' to authenticate."));
+  process.exit(1);
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  console.log(chalk4.bold("\n\u{1F680} AeroCoding CLI Login\n"));
+  const tokenManager = new TokenManager();
+  const existingToken = await tokenManager.getAccessToken();
+  if (existingToken) {
+    const metadata = await tokenManager.getUserMetadata();
+    console.log(
+      chalk4.yellow("\u26A0\uFE0F  Already logged in as:"),
+      chalk4.white(metadata?.email || "unknown")
+    );
+    console.log(
+      chalk4.gray(
+        "   Run 'aerocoding logout' to login with a different account\n"
+      )
+    );
+    return;
+  }
+  try {
+    const deviceFlow = new DeviceFlow();
+    const tokens = await deviceFlow.initiateAuth();
+    const apiClient = createApiClientWithAutoLogout(
+      tokens.access_token,
+      tokenManager
+    );
+    let user;
+    try {
+      user = await apiClient.getCurrentUser();
+    } catch (error) {
+      if (error.response?.status === 401) {
+        await handleUnauthorized(tokenManager);
+      }
+      throw error;
+    }
+    await tokenManager.saveTokens(tokens.access_token, tokens.refresh_token, {
+      id: user.id,
+      email: user.email,
+      name: user.name || void 0,
+      tier: user.tier
+    });
+    console.log("");
+    console.log(
+      chalk4.green("\u2713 Successfully logged in as:"),
+      chalk4.white(user.email)
+    );
+    console.log(chalk4.gray("  Plan:"), chalk4.cyan(user.tier.toUpperCase()));
+    console.log(chalk4.gray("  Run 'aerocoding whoami' to verify\n"));
+  } catch (error) {
+    console.error(
+      chalk4.red("\n\u2717 Login failed:"),
+      error.message || "Unknown error"
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/logout.ts
+import chalk5 from "chalk";
+async function logoutCommand() {
+  const tokenManager = new TokenManager();
+  const metadata = await tokenManager.getUserMetadata();
+  if (!metadata) {
+    console.log(chalk5.yellow("\u26A0\uFE0F  Not logged in"));
+    return;
+  }
+  const email = metadata.email;
+  await tokenManager.logout();
+  console.log(chalk5.green("\u2713 Logged out successfully"));
+  console.log(chalk5.gray(`  Cleared credentials for ${email}
+`));
+}
+
+// src/commands/whoami.ts
+import chalk6 from "chalk";
+async function whoamiCommand() {
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    console.log(chalk6.red("\u2717 Not logged in"));
+    console.log(chalk6.gray("  Run 'aerocoding login' to authenticate\n"));
+    return;
+  }
+  try {
+    const apiClient = createApiClientWithAutoLogout(token, tokenManager);
+    const user = await apiClient.getCurrentUser();
+    console.log("");
+    console.log(chalk6.white("Logged in as:"), chalk6.cyan.bold(user.email));
+    console.log(chalk6.gray("User ID:"), user.id);
+    console.log(chalk6.gray("Plan:"), chalk6.cyan(user.tier.toUpperCase()));
+    if (user.name) {
+      console.log(chalk6.gray("Name:"), user.name);
+    }
+    console.log("");
+  } catch (error) {
+    console.error(chalk6.red("\u2717 Failed to get user info"));
+    if (error.response?.status === 401) {
+      await handleUnauthorized(tokenManager);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import chalk9 from "chalk";
+import ora2 from "ora";
+
+// src/utils/file-writer.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk7 from "chalk";
+function isPathSafe(outputDir, filePath) {
+  const resolvedOutput = path.resolve(outputDir);
+  const resolvedFile = path.resolve(outputDir, filePath);
+  return resolvedFile.startsWith(resolvedOutput + path.sep) || resolvedFile === resolvedOutput;
+}
+async function writeGeneratedFiles(files, outputDir) {
+  for (const file of files) {
+    if (!isPathSafe(outputDir, file.path)) {
+      console.error(
+        chalk7.red(`  \u2717 Skipping unsafe path: ${file.path}`)
+      );
+      console.error(
+        chalk7.gray(`    Path traversal detected - file path must be within output directory`)
+      );
+      continue;
+    }
+    const fullPath = path.resolve(outputDir, file.path);
+    const dir = path.dirname(fullPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(fullPath, file.content, "utf-8");
+      console.log(chalk7.gray(`  \u2713 ${file.path}`));
+    } catch (error) {
+      console.error(chalk7.red(`  \u2717 Failed to write ${file.path}`));
+      console.error(chalk7.gray(`    ${error.message}`));
+    }
+  }
+}
+
+// src/utils/prompt.ts
+import readline from "readline";
+import chalk8 from "chalk";
+function promptConfirm(message) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(chalk8.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("./generated"),
+  backend: z.object({
+    preset: z.string(),
+    layers: z.array(z.string())
+  }).optional(),
+  frontend: z.object({
+    preset: z.string(),
+    layers: z.array(z.string())
+  }).optional(),
+  codeStyle: z.object({
+    includeValidations: z.boolean().default(true),
+    includeComments: z.boolean().default(true),
+    includeAnnotations: z.boolean().default(true),
+    includeLogging: z.boolean().default(true),
+    includeTesting: z.boolean().default(true)
+  }).default({}),
+  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.app/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 buildTargetsFromConfig(config) {
+  if (!config) return [];
+  const targets = [];
+  if (config.backend?.preset) {
+    targets.push("backend");
+  }
+  if (config.frontend?.preset) {
+    targets.push("frontend");
+  }
+  return targets;
+}
+async function generateCommand(options) {
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    console.log(chalk9.red("\n  Not authenticated"));
+    console.log(chalk9.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(chalk9.red("\n  Project ID required"));
+    console.log(chalk9.gray("  Run 'aerocoding init' to create a config file"));
+    console.log(chalk9.gray("  Or use --project <id> to specify a project\n"));
+    process.exit(1);
+  }
+  const targets = options.targets || buildTargetsFromConfig(config);
+  const output = options.output || config?.output || "./generated";
+  const backendPreset = options.backendPreset || config?.backend?.preset;
+  const frontendPreset = options.frontendPreset || config?.frontend?.preset;
+  const backendLayers = options.backendLayers || config?.backend?.layers;
+  const frontendLayers = options.frontendLayers || config?.frontend?.layers;
+  const validationLib = options.validationLib || config?.libraries?.validation;
+  const includeValidations = options.validations ?? config?.codeStyle?.includeValidations ?? true;
+  const includeComments = options.comments ?? config?.codeStyle?.includeComments ?? true;
+  const includeAnnotations = options.annotations ?? config?.codeStyle?.includeAnnotations ?? 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(chalk9.gray(`Project: ${project.name}`));
+    spinner2 = ora2({ text: "Checking credits...", color: "cyan" }).start();
+    const credits = await apiClient.getCreditUsage(project.organizationId);
+    spinner2.succeed(chalk9.gray(`Credits: ${credits.remaining} / ${credits.limit} available`));
+    console.log("");
+    console.log(chalk9.bold("  Generation Summary"));
+    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"));
+    console.log(chalk9.gray("  Project:"), chalk9.white(project.name));
+    if (config) {
+      console.log(chalk9.gray("  Config:"), chalk9.cyan(".aerocodingrc.json"));
+    }
+    console.log(
+      chalk9.gray("  Targets:"),
+      chalk9.cyan(targets.length > 0 ? targets.join(", ") : "default")
+    );
+    if (backendPreset) {
+      console.log(chalk9.gray("  Backend Preset:"), chalk9.cyan(backendPreset));
+    }
+    if (frontendPreset) {
+      console.log(chalk9.gray("  Frontend Preset:"), chalk9.cyan(frontendPreset));
+    }
+    const disabledOptions = [];
+    if (!includeValidations) disabledOptions.push("validations");
+    if (!includeComments) disabledOptions.push("comments");
+    if (!includeAnnotations) disabledOptions.push("annotations");
+    if (!includeLogging) disabledOptions.push("logging");
+    if (!includeTesting) disabledOptions.push("testing");
+    if (disabledOptions.length > 0) {
+      console.log(chalk9.gray("  Disabled:"), chalk9.yellow(disabledOptions.join(", ")));
+    }
+    if (validationLib) {
+      console.log(chalk9.gray("  Validation Lib:"), chalk9.cyan(validationLib));
+    }
+    console.log(
+      chalk9.gray("  Credits:"),
+      credits.remaining > 50 ? chalk9.green(`${credits.remaining} available`) : chalk9.yellow(`${credits.remaining} available (low)`)
+    );
+    console.log(chalk9.gray("  Output:"), chalk9.cyan(output));
+    console.log("");
+    if (!options.yes) {
+      const confirmed = await promptConfirm("  Proceed with generation?");
+      if (!confirmed) {
+        console.log(chalk9.yellow("\n  Generation cancelled\n"));
+        process.exit(0);
+      }
+    }
+    console.log("");
+    spinner2 = ora2({ text: "Generating code...", color: "cyan" }).start();
+    const result = await apiClient.generateCode({
+      projectId,
+      targets,
+      options: {
+        includeValidations,
+        includeComments,
+        includeAnnotations,
+        includeLogging,
+        includeTesting,
+        outputDir: output,
+        backendPreset,
+        frontendPreset,
+        backendLayers,
+        frontendLayers,
+        validationLib
+      }
+    });
+    spinner2.succeed(chalk9.green("Code generated successfully!"));
+    console.log("");
+    console.log(chalk9.bold("  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"));
+    console.log(chalk9.gray("  Files:"), chalk9.cyan(result.stats.totalFiles));
+    console.log(chalk9.gray("  Entities:"), chalk9.cyan(result.stats.totalEntities));
+    console.log(
+      chalk9.gray("  Languages:"),
+      chalk9.cyan(result.stats.languages.join(", "))
+    );
+    if (result.creditsUsed !== void 0) {
+      console.log("");
+      console.log(chalk9.bold("  Credits"));
+      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"));
+      console.log(chalk9.gray("  Used:"), chalk9.yellow(result.creditsUsed));
+      console.log(
+        chalk9.gray("  Remaining:"),
+        result.creditsRemaining !== void 0 && result.creditsRemaining > 50 ? chalk9.green(result.creditsRemaining) : chalk9.yellow(result.creditsRemaining)
+      );
+    }
+    if (result.warnings && result.warnings.length > 0) {
+      console.log("");
+      console.log(chalk9.yellow("  Warnings:"));
+      for (const warning of result.warnings) {
+        console.log(chalk9.yellow(`    - ${warning}`));
+      }
+    }
+    console.log("");
+    await writeGeneratedFiles(result.files, output);
+    console.log(chalk9.green(`  Files written to ${chalk9.white(output)}`));
+    console.log("");
+  } catch (error) {
+    spinner2.fail(chalk9.red("Generation failed"));
+    if (error.response?.status === 401) {
+      await handleUnauthorized(tokenManager);
+    } else if (error.response?.status === 403) {
+      console.log(chalk9.yellow("\n  You don't have permission to access this project."));
+      console.log(chalk9.gray("  Check if you're part of the organization.\n"));
+    } else if (error.response?.status === 404) {
+      console.log(chalk9.yellow("\n  Project not found."));
+      console.log(chalk9.gray("  Check if the project ID is correct.\n"));
+    } else if (error.response?.status === 429) {
+      const data = error.response.data;
+      console.log(chalk9.red("\n  Insufficient credits"));
+      if (data.requiredCredits) {
+        console.log(chalk9.yellow(`  Required: ${data.requiredCredits} credits`));
+      }
+      console.log(chalk9.yellow(`  Available: ${data.remaining ?? 0} credits`));
+      console.log(chalk9.gray("\n  Upgrade your plan or wait for credit reset.\n"));
+    } else if (error.response?.data?.message) {
+      console.log(chalk9.red(`
+  ${error.response.data.message}
+`));
+    } else {
+      console.log(chalk9.red(`
+  ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import chalk10 from "chalk";
+async function initCommand(options) {
+  p.intro(chalk10.bgCyan.black(" AeroCoding CLI "));
+  if (!options.force && await configExists()) {
+    const overwrite = await p.confirm({
+      message: "Config file already exists. Overwrite?",
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+  const tokenManager = new TokenManager();
+  const token = await tokenManager.getAccessToken();
+  if (!token) {
+    p.cancel("Not logged in. Run 'aerocoding login' first.");
+    process.exit(1);
+  }
+  const apiClient = createApiClientWithAutoLogout(token, tokenManager);
+  try {
+    let projectId = options.project;
+    if (!projectId) {
+      const spinner3 = p.spinner();
+      spinner3.start("Loading projects...");
+      const projects = await apiClient.listProjects();
+      spinner3.stop("Projects loaded");
+      if (projects.length === 0) {
+        p.cancel("No projects found. Create a project on aerocoding.app first.");
+        process.exit(1);
+      }
+      const selectedProject = await p.select({
+        message: "Select project",
+        options: projects.map((proj) => ({
+          value: proj.id,
+          label: proj.name,
+          hint: [proj.backendFramework, proj.frontendFramework].filter(Boolean).join(" + ")
+        }))
+      });
+      if (p.isCancel(selectedProject)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      projectId = selectedProject;
+    }
+    const spinner2 = p.spinner();
+    spinner2.start("Fetching project details...");
+    const project = await apiClient.getProject(projectId);
+    spinner2.stop(`Project: ${project.name}`);
+    const targetOptions = [];
+    if (project.backendFramework) {
+      targetOptions.push({
+        value: "backend",
+        label: `Backend (${project.backendFramework})`
+      });
+    }
+    if (project.frontendFramework) {
+      targetOptions.push({
+        value: "frontend",
+        label: `Frontend (${project.frontendFramework})`
+      });
+    }
+    if (targetOptions.length === 0) {
+      p.cancel("Project has no frameworks configured. Update it on aerocoding.app first.");
+      process.exit(1);
+    }
+    const targets = await p.multiselect({
+      message: "What do you want to generate?",
+      options: targetOptions,
+      required: true
+    });
+    if (p.isCancel(targets)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const selectedTargets = targets;
+    const config = {
+      project: projectId,
+      output: "./generated",
+      codeStyle: {
+        includeValidations: true,
+        includeComments: true,
+        includeAnnotations: true,
+        includeLogging: true,
+        includeTesting: true
+      }
+    };
+    if (selectedTargets.includes("backend") && project.backendFramework) {
+      const archSpinner = p.spinner();
+      archSpinner.start("Loading backend architectures...");
+      const architectures = await apiClient.getArchitectures(project.backendFramework);
+      archSpinner.stop("Architectures loaded");
+      if (architectures.length > 0) {
+        const preset = await p.select({
+          message: "Backend architecture",
+          options: architectures.map((arch) => ({
+            value: arch.id,
+            label: arch.name,
+            hint: arch.description
+          }))
+        });
+        if (p.isCancel(preset)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const selectedArch = architectures.find((a) => a.id === preset);
+        if (selectedArch && selectedArch.layers.length > 0) {
+          const layers = await p.multiselect({
+            message: "Select backend layers to include",
+            options: selectedArch.layers.map((layer) => ({
+              value: layer.id,
+              label: layer.name,
+              hint: layer.category
+            })),
+            initialValues: selectedArch.layers.map((l) => l.id)
+          });
+          if (p.isCancel(layers)) {
+            p.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          config.backend = {
+            preset,
+            layers
+          };
+        } else {
+          config.backend = {
+            preset,
+            layers: []
+          };
+        }
+      }
+    }
+    if (selectedTargets.includes("frontend") && project.frontendFramework) {
+      const archSpinner = p.spinner();
+      archSpinner.start("Loading frontend architectures...");
+      const architectures = await apiClient.getArchitectures(project.frontendFramework);
+      archSpinner.stop("Architectures loaded");
+      if (architectures.length > 0) {
+        const preset = await p.select({
+          message: "Frontend architecture",
+          options: architectures.map((arch) => ({
+            value: arch.id,
+            label: arch.name,
+            hint: arch.description
+          }))
+        });
+        if (p.isCancel(preset)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const selectedArch = architectures.find((a) => a.id === preset);
+        if (selectedArch && selectedArch.layers.length > 0) {
+          const layers = await p.multiselect({
+            message: "Select frontend layers to include",
+            options: selectedArch.layers.map((layer) => ({
+              value: layer.id,
+              label: layer.name,
+              hint: layer.category
+            })),
+            initialValues: selectedArch.layers.map((l) => l.id)
+          });
+          if (p.isCancel(layers)) {
+            p.cancel("Operation cancelled.");
+            process.exit(0);
+          }
+          config.frontend = {
+            preset,
+            layers
+          };
+        } else {
+          config.frontend = {
+            preset,
+            layers: []
+          };
+        }
+      }
+    }
+    const codeStyleOptions = await p.multiselect({
+      message: "Code style options",
+      options: [
+        { value: "validations", label: "Include validations", hint: "Add validation rules" },
+        { value: "comments", label: "Include comments", hint: "Add code documentation" },
+        { value: "annotations", label: "Include annotations", hint: "Add decorators/attributes" },
+        { value: "logging", label: "Include logging", hint: "Add log statements" },
+        { value: "testing", label: "Include tests", hint: "Generate test files" }
+      ],
+      initialValues: ["validations", "comments", "annotations", "logging", "testing"]
+    });
+    if (p.isCancel(codeStyleOptions)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const selectedStyles = codeStyleOptions;
+    config.codeStyle = {
+      includeValidations: selectedStyles.includes("validations"),
+      includeComments: selectedStyles.includes("comments"),
+      includeAnnotations: selectedStyles.includes("annotations"),
+      includeLogging: selectedStyles.includes("logging"),
+      includeTesting: selectedStyles.includes("testing")
+    };
+    const output = await p.text({
+      message: "Output directory",
+      initialValue: "./generated",
+      validate: (value) => {
+        if (!value) return "Output directory is required";
+        return void 0;
+      }
+    });
+    if (p.isCancel(output)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    config.output = output;
+    await saveConfig(config);
+    p.outro(
+      chalk10.green("Config saved to .aerocodingrc.json") + "\n\n" + chalk10.gray("  Run ") + chalk10.cyan("aerocoding generate") + chalk10.gray(" to generate code!")
+    );
+  } catch (error) {
+    if (error.response?.status === 401) {
+      await handleUnauthorized(tokenManager);
+    } else if (error.response?.data?.message) {
+      p.cancel(error.response.data.message);
+    } else {
+      p.cancel(error.message || "An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/pull.ts
+import chalk11 from "chalk";
+async function pullCommand(options) {
+  console.log(chalk11.yellow("\u26A0\uFE0F  Command not yet implemented"));
+  if (options.project) {
+    console.log(chalk11.gray(`  Requested project: ${options.project}`));
+  }
+  console.log(chalk11.gray("  Coming soon in v0.2.0\n"));
+}
+
+// src/commands/status.ts
+import chalk12 from "chalk";
+async function statusCommand() {
+  console.log(chalk12.yellow("\u26A0\uFE0F  Command not yet implemented"));
+  console.log(chalk12.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.0");
+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", "./generated").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("-y, --yes", "Skip confirmation prompt").action(generateCommand);
+program.parse();
+//# sourceMappingURL=index.js.map