@genui/a3-create 0.1.36

package/dist/index.js

@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { execSync } from "child_process";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import * as p2 from "@clack/prompts";
+import chalk from "chalk";
+import fs3 from "fs-extra";
+
+// src/utils/generators.ts
+import path from "path";
+import fs from "fs-extra";
+
+// src/utils/providers/providersMeta.json
+var providersMeta_default = {
+  openai: {
+    label: "OpenAI",
+    exportName: "getOpenAIProvider",
+    file: "openai.ts",
+    npmPackage: "@genui/a3-openai",
+    urls: {
+      keys: "https://platform.openai.com/account/api-keys"
+    }
+  },
+  bedrock: {
+    label: "AWS Bedrock",
+    exportName: "getBedrockProvider",
+    file: "bedrock.ts",
+    npmPackage: "@genui/a3-bedrock",
+    urls: {
+      keys: "https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html",
+      configure: "https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html",
+      credentials: "https://console.aws.amazon.com/iam/home#/security_credentials",
+      docs: "https://docs.aws.amazon.com/bedrock/latest/userguide/"
+    }
+  },
+  anthropic: {
+    label: "Anthropic",
+    exportName: "getAnthropicProvider",
+    file: "anthropic.ts",
+    npmPackage: "@genui/a3-anthropic",
+    urls: {
+      keys: "https://console.anthropic.com/settings/keys"
+    }
+  }
+};
+
+// src/utils/providers/index.ts
+var PROVIDER_META = providersMeta_default;
+function providerDocName(key) {
+  return `PROVIDER-${key.toUpperCase()}.md`;
+}
+
+// src/utils/generators.ts
+function generateProviderFiles(targetDir, config) {
+  const providersDir = path.join(targetDir, "app", "lib", "providers");
+  const docsDir = path.join(targetDir, "docs");
+  for (const [key, meta] of Object.entries(PROVIDER_META)) {
+    if (!config.providers.includes(key)) {
+      const filePath = path.join(providersDir, meta.file);
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+      const docPath = path.join(docsDir, providerDocName(key));
+      if (fs.existsSync(docPath)) fs.unlinkSync(docPath);
+    }
+  }
+  const primaryMeta = PROVIDER_META[config.primaryProvider];
+  const lines = [];
+  for (const provKey of config.providers) {
+    const meta = PROVIDER_META[provKey];
+    const baseName = meta.file.replace(".ts", "");
+    lines.push(`export { ${meta.exportName} } from './${baseName}'`);
+  }
+  lines.push(`export { ${primaryMeta.exportName} as getProvider } from './${primaryMeta.file.replace(".ts", "")}'`);
+  lines.push("");
+  fs.outputFileSync(path.join(providersDir, "index.ts"), lines.join("\n"));
+  const pkgJsonPath = path.join(targetDir, "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = fs.readJsonSync(pkgJsonPath);
+    for (const [key, meta] of Object.entries(PROVIDER_META)) {
+      if (!config.providers.includes(key) && pkg.dependencies?.[meta.npmPackage]) {
+        delete pkg.dependencies[meta.npmPackage];
+      }
+    }
+    fs.writeJsonSync(pkgJsonPath, pkg, { spaces: 2 });
+  }
+}
+function generateEnvFile(targetDir, config) {
+  const lines = [
+    "# Generated by create-genui-a3",
+    "# This file is git-ignored. Do not commit credentials.",
+    ""
+  ];
+  if (config.providers.includes("openai")) {
+    lines.push("# OpenAI", `OPENAI_API_KEY=${config.openaiApiKey || ""}`, "");
+  }
+  if (config.providers.includes("anthropic")) {
+    lines.push("# Anthropic", `ANTHROPIC_API_KEY=${config.anthropicApiKey || ""}`, "");
+  }
+  if (config.providers.includes("bedrock")) {
+    if (config.bedrockAuthMode === "profile") {
+      lines.push("# AWS Bedrock (profile mode)", `AWS_PROFILE=${config.awsProfile || "default"}`);
+    } else {
+      lines.push(
+        "# AWS Bedrock (access keys)",
+        `AWS_ACCESS_KEY_ID=${config.awsAccessKeyId || ""}`,
+        `AWS_SECRET_ACCESS_KEY=${config.awsSecretAccessKey || ""}`
+      );
+    }
+    lines.push(`AWS_REGION=${config.awsRegion || "us-east-1"}`, "");
+  }
+  fs.writeFileSync(path.join(targetDir, ".env"), lines.join("\n"));
+}
+function scaffoldProject(templateDir, targetDir, projectName) {
+  fs.copySync(templateDir, targetDir);
+  const pkgJsonPath = path.join(targetDir, "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = fs.readJsonSync(pkgJsonPath);
+    pkg.name = projectName;
+    delete pkg.private;
+    fs.writeJsonSync(pkgJsonPath, pkg, { spaces: 2 });
+  }
+  const gitignoreSrc = path.join(targetDir, "_gitignore");
+  if (fs.existsSync(gitignoreSrc)) {
+    fs.renameSync(gitignoreSrc, path.join(targetDir, ".gitignore"));
+  }
+  try {
+    const cursorrulesPath = path.join(targetDir, ".cursorrules");
+    const claudeMdPath = path.join(targetDir, "CLAUDE.md");
+    if (fs.existsSync(claudeMdPath)) {
+      fs.symlinkSync("CLAUDE.md", cursorrulesPath, "file");
+    }
+  } catch {
+    try {
+      fs.copyFileSync(path.join(targetDir, "CLAUDE.md"), path.join(targetDir, ".cursorrules"));
+    } catch {
+    }
+  }
+}
+
+// src/utils/prompts.ts
+import * as p from "@clack/prompts";
+
+// src/utils/aws.ts
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+function detectAwsProfiles() {
+  try {
+    const credentialsPath = process.env.AWS_SHARED_CREDENTIALS_FILE || path2.join(os.homedir(), ".aws", "credentials");
+    const content = fs2.readFileSync(credentialsPath, "utf-8");
+    const profiles = [];
+    const regex = /^\[([^\]]+)\]$/gm;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      profiles.push(match[1]);
+    }
+    return profiles;
+  } catch {
+    return [];
+  }
+}
+function detectAwsProfileRegion(profileName) {
+  try {
+    const credentialsPath = process.env.AWS_SHARED_CREDENTIALS_FILE || path2.join(os.homedir(), ".aws", "credentials");
+    const content = fs2.readFileSync(credentialsPath, "utf-8");
+    const region = extractRegionFromIni(content, profileName);
+    if (region) return region;
+  } catch {
+  }
+  try {
+    const configPath = process.env.AWS_CONFIG_FILE || path2.join(os.homedir(), ".aws", "config");
+    const content = fs2.readFileSync(configPath, "utf-8");
+    const sectionName = profileName === "default" ? profileName : `profile ${profileName}`;
+    const region = extractRegionFromIni(content, sectionName);
+    if (region) return region;
+  } catch {
+  }
+  return void 0;
+}
+function extractRegionFromIni(content, sectionName) {
+  const lines = content.split("\n");
+  let inSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      const name = trimmed.slice(1, -1);
+      inSection = name === sectionName;
+      continue;
+    }
+    if (inSection && trimmed.startsWith("region")) {
+      const match = /^region\s*=\s*(.+)$/.exec(trimmed);
+      if (match) return match[1].trim();
+    }
+  }
+  return void 0;
+}
+
+// src/utils/validation.ts
+function normalizeKey(key) {
+  return key.replace(/\s/g, "");
+}
+function buildErrorMessage({
+  detail,
+  provider,
+  helpUrl
+}) {
+  let message = `${provider} API key error: ${detail}
+
+Make sure:
+  \u2022 Your credentials are active and not revoked
+  \u2022 Your account has appropriate permissions
+  \u2022 The credentials haven't exceeded rate limits`;
+  if (helpUrl) {
+    message += `
+
+Get help at: ${helpUrl}`;
+  }
+  return message;
+}
+async function validateOpenAIKey(apiKey) {
+  if (!apiKey.startsWith("sk-proj-")) {
+    return {
+      valid: false,
+      message: `Invalid format: OpenAI API key must start with sk-proj-
+
+Get a new key at: ${providersMeta_default.openai.urls.keys}`
+    };
+  }
+  try {
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "gpt-4o-mini",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (response.ok) {
+      return { valid: true, message: "OpenAI API key verified \u2014 completions working." };
+    }
+    const body = await response.json().catch(() => null);
+    const detail = body?.error?.message ?? `HTTP ${response.status}`;
+    return { valid: false, message: buildErrorMessage({ detail, provider: "OpenAI" }) };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { valid: false, message: `Network error: ${msg}` };
+  }
+}
+async function validateAnthropicKey(apiKey) {
+  if (!apiKey.startsWith("sk-ant-")) {
+    return {
+      valid: false,
+      message: `Invalid format: Anthropic API key must start with sk-ant-
+
+Get a new key at: ${providersMeta_default.anthropic.urls.keys}`
+    };
+  }
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (response.ok) {
+      return { valid: true, message: "Anthropic API key verified \u2014 completions working." };
+    }
+    const body = await response.json().catch(() => null);
+    const detail = body?.error?.message ?? `HTTP ${response.status}`;
+    return {
+      valid: false,
+      message: buildErrorMessage({ detail, provider: "Anthropic", helpUrl: providersMeta_default.anthropic.urls.keys })
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { valid: false, message: `Network error: ${msg}` };
+  }
+}
+async function validateAwsCredentials(credentials) {
+  if (credentials.mode === "keys") {
+    if (!credentials.accessKeyId.match(/^AKIA[0-9A-Z]{16}$/)) {
+      return {
+        valid: false,
+        message: `Invalid format: AWS Access Key ID must start with AKIA and be 20 characters total
+
+Manage keys at: ${providersMeta_default.bedrock.urls.keys}`
+      };
+    }
+    if (credentials.secretAccessKey.length < 40) {
+      return {
+        valid: false,
+        message: `Invalid format: AWS Secret Access Key appears too short (should be ~40 characters)
+
+Manage keys at: ${providersMeta_default.bedrock.urls.keys}`
+      };
+    }
+  }
+  try {
+    const { BedrockClient, ListFoundationModelsCommand } = await import("@aws-sdk/client-bedrock");
+    let clientConfig;
+    if (credentials.mode === "profile") {
+      const { fromIni } = await import("@aws-sdk/credential-provider-ini");
+      clientConfig = {
+        region: credentials.region,
+        credentials: fromIni({ profile: credentials.profile })
+      };
+    } else {
+      clientConfig = {
+        region: credentials.region,
+        credentials: {
+          accessKeyId: credentials.accessKeyId,
+          secretAccessKey: credentials.secretAccessKey
+        }
+      };
+    }
+    const client = new BedrockClient(clientConfig);
+    await client.send(new ListFoundationModelsCommand({ byOutputModality: "TEXT" }));
+    return { valid: true, message: "AWS credentials verified with Bedrock access." };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    let message = `AWS validation failed: ${msg}`;
+    if (msg.includes("Could not resolve credentials")) {
+      const profile = credentials.mode === "profile" ? credentials.profile : "unknown";
+      message = `Could not find credentials for profile "${profile}" in ~/.aws/credentials
+
+Set up a profile with: aws configure
+  Guide: ${providersMeta_default.bedrock.urls.configure}`;
+    } else if (msg.includes("InvalidSignatureException") || msg.includes("InvalidSignature")) {
+      message = `Invalid AWS credentials (signature mismatch)
+
+Make sure:
+  \u2022 Your Access Key ID and Secret Access Key are correct
+  \u2022 They haven't been revoked or rotated
+
+Manage credentials at: ${providersMeta_default.bedrock.urls.credentials}`;
+    } else if (msg.includes("UnauthorizedOperation") || msg.includes("NotAuthorizedForSourceException")) {
+      message = `AWS credentials don't have permission to access Bedrock
+
+Make sure:
+  \u2022 Your IAM user/role has Bedrock access
+  \u2022 Your region has Bedrock enabled
+
+Learn more: ${providersMeta_default.bedrock.urls.docs}`;
+    }
+    return { valid: false, message };
+  }
+}
+
+// src/utils/prompts.ts
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Setup cancelled.");
+    process.exit(1);
+  }
+}
+async function promptProjectName() {
+  let projectName = process.argv[2];
+  if (!projectName) {
+    const value = await p.text({
+      message: "What is your project named?",
+      placeholder: "my-a3-quickstart",
+      defaultValue: "my-a3-quickstart"
+    });
+    handleCancel(value);
+    projectName = value.trim();
+  }
+  return projectName;
+}
+async function promptAccessKeys(config) {
+  p.log.info(
+    "You'll need AWS access keys to authenticate with Bedrock.\n  Create or manage keys at: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html"
+  );
+  const awsAccessKeyId = await p.text({
+    message: "AWS_ACCESS_KEY_ID:",
+    validate(input) {
+      if (!input) return "Access key ID is required.";
+    }
+  });
+  handleCancel(awsAccessKeyId);
+  config.awsAccessKeyId = normalizeKey(awsAccessKeyId);
+  const awsSecretAccessKey = await p.password({
+    message: "AWS_SECRET_ACCESS_KEY:",
+    validate(input) {
+      if (!input) return "Secret access key is required.";
+    }
+  });
+  handleCancel(awsSecretAccessKey);
+  config.awsSecretAccessKey = normalizeKey(awsSecretAccessKey);
+}
+async function promptOpenAIConfig(config) {
+  p.log.step(PROVIDER_META.openai.label);
+  let validated = false;
+  while (!validated) {
+    const openaiApiKey = await p.password({
+      message: "OpenAI API key:",
+      validate(input) {
+        if (!input) return "API key is required (starts with sk-...). Get one at https://platform.openai.com/api-keys";
+      }
+    });
+    handleCancel(openaiApiKey);
+    config.openaiApiKey = normalizeKey(openaiApiKey);
+    const spin = p.spinner();
+    spin.start("Validating OpenAI credentials...");
+    const result = await validateOpenAIKey(config.openaiApiKey);
+    spin.stop(result.valid ? "OpenAI credentials verified" : "OpenAI validation failed");
+    if (result.valid) {
+      validated = true;
+    } else {
+      p.log.warn(result.message);
+      p.log.info("Please try again.");
+    }
+  }
+}
+async function promptAnthropicConfig(config) {
+  p.log.step(PROVIDER_META.anthropic.label);
+  let validated = false;
+  while (!validated) {
+    const anthropicApiKey = await p.password({
+      message: "Anthropic API key:",
+      validate(input) {
+        if (!input)
+          return "API key is required (starts with sk-ant-...). Get one at https://console.anthropic.com/settings/keys";
+      }
+    });
+    handleCancel(anthropicApiKey);
+    config.anthropicApiKey = normalizeKey(anthropicApiKey);
+    const spin = p.spinner();
+    spin.start("Validating Anthropic credentials...");
+    const result = await validateAnthropicKey(config.anthropicApiKey);
+    spin.stop(result.valid ? "Anthropic credentials verified" : "Anthropic validation failed");
+    if (result.valid) {
+      validated = true;
+    } else {
+      p.log.warn(result.message);
+      p.log.info("Please try again.");
+    }
+  }
+}
+async function promptProfileSelection(profiles) {
+  const MANUAL_ENTRY = "__manual__";
+  const awsProfile = await p.select({
+    message: "AWS profile",
+    options: [
+      ...profiles.map((prof) => ({ label: prof, value: prof })),
+      { label: "Enter manually", value: MANUAL_ENTRY }
+    ]
+  });
+  handleCancel(awsProfile);
+  if (awsProfile === MANUAL_ENTRY) {
+    const manualProfile = await p.text({
+      message: "AWS profile name:",
+      placeholder: "default",
+      defaultValue: "default",
+      validate(input) {
+        if (!input) return "Profile name is required.";
+      }
+    });
+    handleCancel(manualProfile);
+    return manualProfile.trim();
+  }
+  return awsProfile;
+}
+async function promptDetectProfile(config) {
+  const profiles = detectAwsProfiles();
+  if (profiles.length > 0) {
+    return promptProfileSelection(profiles);
+  }
+  while (true) {
+    p.log.warn("No AWS profiles found in ~/.aws/credentials");
+    p.log.info(
+      "Set up a profile with: aws configure\n  Guide: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html"
+    );
+    const action = await p.select({
+      message: "How would you like to proceed?",
+      options: [
+        { label: "Try again", value: "retry", hint: "Re-check ~/.aws/credentials" },
+        { label: "Use access keys instead", value: "keys", hint: "Provide key ID + secret directly" }
+      ]
+    });
+    handleCancel(action);
+    if (action === "keys") {
+      config.bedrockAuthMode = "keys";
+      await promptAccessKeys(config);
+      return null;
+    }
+    const retryProfiles = detectAwsProfiles();
+    if (retryProfiles.length > 0) {
+      return promptProfileSelection(retryProfiles);
+    }
+  }
+}
+async function promptBedrockConfig(config) {
+  p.log.step(PROVIDER_META.bedrock.label);
+  const authMode = await p.select({
+    message: "How do you want to authenticate with AWS Bedrock?",
+    options: [
+      { label: "AWS Profile (recommended)", value: "profile", hint: "Uses ~/.aws/credentials" },
+      { label: "Access Keys", value: "keys", hint: "Provide key ID + secret directly" }
+    ]
+  });
+  handleCancel(authMode);
+  config.bedrockAuthMode = authMode;
+  if (authMode === "profile") {
+    const profile = await promptDetectProfile(config);
+    if (profile) config.awsProfile = profile;
+  } else {
+    await promptAccessKeys(config);
+  }
+  let validated = false;
+  let firstAttempt = true;
+  while (!validated) {
+    if (!firstAttempt) {
+      if (config.bedrockAuthMode === "keys") {
+        await promptAccessKeys(config);
+      } else {
+        const retryAction = await p.select({
+          message: "How would you like to retry?",
+          options: [
+            { label: "Try a different profile", value: "profile" },
+            { label: "Switch to access keys", value: "keys" }
+          ]
+        });
+        handleCancel(retryAction);
+        if (retryAction === "keys") {
+          config.bedrockAuthMode = "keys";
+          await promptAccessKeys(config);
+        } else {
+          const profile = await promptDetectProfile(config);
+          if (profile) config.awsProfile = profile;
+        }
+      }
+    }
+    firstAttempt = false;
+    const currentDetectedRegion = config.bedrockAuthMode === "profile" ? detectAwsProfileRegion(config.awsProfile) : void 0;
+    const awsRegion = await p.text({
+      message: "AWS region:",
+      ...currentDetectedRegion ? { initialValue: currentDetectedRegion } : { placeholder: "us-east-1" },
+      validate(input) {
+        if (!input) return "AWS region is required.";
+      }
+    });
+    handleCancel(awsRegion);
+    config.awsRegion = awsRegion.trim();
+    const spin = p.spinner();
+    spin.start("Validating AWS Bedrock credentials...");
+    const credentialInput = config.bedrockAuthMode === "profile" ? { mode: "profile", profile: config.awsProfile, region: config.awsRegion } : {
+      mode: "keys",
+      accessKeyId: config.awsAccessKeyId,
+      secretAccessKey: config.awsSecretAccessKey,
+      region: config.awsRegion
+    };
+    const result = await validateAwsCredentials(credentialInput);
+    spin.stop(result.valid ? "AWS Bedrock credentials verified" : "AWS Bedrock validation failed");
+    if (result.valid) {
+      validated = true;
+    } else {
+      p.log.warn(result.message);
+      p.log.info("Re-entering credentials...");
+    }
+  }
+}
+async function promptPrimaryProvider(providers, config) {
+  const primaryProvider = await p.select({
+    message: "Which provider should the app use by default?",
+    options: providers.map((prov) => ({ label: PROVIDER_META[prov].label, value: prov }))
+  });
+  handleCancel(primaryProvider);
+  config.primaryProvider = primaryProvider;
+}
+async function promptProviders() {
+  const providers = await p.multiselect({
+    message: "Which LLM provider(s) do you want to configure?",
+    options: [
+      { label: "OpenAI", value: "openai" },
+      { label: "AWS Bedrock", value: "bedrock" },
+      { label: "Anthropic", value: "anthropic" }
+    ],
+    required: true
+  });
+  handleCancel(providers);
+  const config = {
+    providers,
+    primaryProvider: providers[0]
+  };
+  if (providers.includes("openai")) {
+    await promptOpenAIConfig(config);
+  }
+  if (providers.includes("bedrock")) {
+    await promptBedrockConfig(config);
+  }
+  if (providers.includes("anthropic")) {
+    await promptAnthropicConfig(config);
+  }
+  if (providers.length > 1) {
+    await promptPrimaryProvider(providers, config);
+  }
+  return config;
+}
+
+// src/index.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var BANNER = `
+  ${chalk.cyan("\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ")}
+  ${chalk.cyan("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2557")}
+  ${chalk.cyan("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2554\u255D")}
+  ${chalk.cyan("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u255A\u2550\u2550\u2550\u2588\u2588\u2557")}
+  ${chalk.cyan("\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D")}
+  ${chalk.cyan("\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D ")}
+
+  ${chalk.white.bold("A3")} ${chalk.dim("\u2014 Agentic App Architecture")}
+`;
+function installDependencies(targetDir, projectName) {
+  try {
+    execSync("npm install --legacy-peer-deps", { cwd: targetDir, stdio: "inherit" });
+  } catch {
+    p2.log.error("Failed to install dependencies. You can try manually:");
+    p2.log.info(`  cd ${projectName}
+  npm install`);
+    process.exit(1);
+  }
+}
+function printSuccess(projectName, targetDir, config) {
+  const { label } = PROVIDER_META[config.primaryProvider];
+  p2.note(
+    [
+      `Primary provider: ${label}`,
+      "Check .env for credentials configuration",
+      "",
+      "Get started:",
+      "",
+      `  cd ${projectName}`,
+      "  npm run dev"
+    ].join("\n"),
+    `Created ${projectName} at ${targetDir}`
+  );
+  p2.outro("Happy building!");
+}
+async function main() {
+  console.log(BANNER);
+  p2.intro("Create a new A3 app");
+  const projectName = await promptProjectName();
+  const targetDir = path3.resolve(process.cwd(), projectName);
+  if (fs3.existsSync(targetDir) && fs3.readdirSync(targetDir).length > 0) {
+    p2.cancel(`Directory "${projectName}" already exists and is not empty.`);
+    process.exit(1);
+  }
+  const templateDir = path3.resolve(__dirname, "..", "template");
+  if (!fs3.existsSync(templateDir)) {
+    p2.cancel("Template directory not found. The package may not have been built correctly.");
+    process.exit(1);
+  }
+  const providerConfig = await promptProviders();
+  p2.log.info(`Creating a new A3 app in ${targetDir}`);
+  const spin = p2.spinner();
+  spin.start("Scaffolding project files");
+  scaffoldProject(templateDir, targetDir, projectName);
+  spin.message("Configuring providers");
+  generateProviderFiles(targetDir, providerConfig);
+  spin.message("Generating .env file");
+  generateEnvFile(targetDir, providerConfig);
+  spin.stop("Project scaffolded");
+  p2.log.step("Installing dependencies...");
+  installDependencies(targetDir, projectName);
+  printSuccess(projectName, targetDir, providerConfig);
+}
+main().catch((err) => {
+  p2.cancel("Unexpected error");
+  console.error(err);
+  process.exit(1);
+});