a3-stack-cli 0.1.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "a3-stack-cli",
+  "version": "0.1.0",
+  "description": "A3 Stack CLI - Create modern full-stack apps with SvelteKit, Better Auth, and Kysely",
+  "type": "module",
+  "bin": {
+    "a3": "./src/index.ts"
+  },
+  "main": "./src/lib/index.ts",
+  "exports": {
+    ".": "./src/lib/index.ts",
+    "./commands": "./src/commands/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run typecheck"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.4.0",
+    "giget": "^2.0.0",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "a3-stack",
+    "sveltekit",
+    "better-auth",
+    "kysely",
+    "cli",
+    "scaffold"
+  ],
+  "author": "Adam Augustinsky",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AdamAugustinsky/a3-stack"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/commands/create.ts

@@ -0,0 +1,197 @@
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { downloadTemplate, listTemplates, processTemplate } from '../lib/template';
+import { initGit, isGitInstalled } from '../lib/git';
+import { installDependencies, runPostInstall } from '../lib/setup';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+export const createCommand = defineCommand({
+  meta: {
+    name: 'create',
+    description: 'Create a new A3 Stack project',
+  },
+  args: {
+    name: {
+      type: 'positional',
+      description: 'Project name',
+      required: false,
+    },
+    template: {
+      type: 'string',
+      alias: 't',
+      description: 'Template to use (e.g., kysely)',
+    },
+    git: {
+      type: 'boolean',
+      description: 'Initialize git repository',
+      default: true,
+    },
+    install: {
+      type: 'boolean',
+      alias: 'i',
+      description: 'Install dependencies',
+      default: true,
+    },
+  },
+  async run({ args }) {
+    console.log('');
+    consola.box({
+      title: 'A3 Stack CLI',
+      message: 'Create modern full-stack apps',
+      style: {
+        borderColor: 'cyan',
+      },
+    });
+    console.log('');
+
+    // Get available templates
+    const templates = await listTemplates();
+
+    // Check if target directory already exists (if name provided)
+    if (args.name) {
+      const targetDir = resolve(process.cwd(), args.name);
+      if (existsSync(targetDir)) {
+        consola.error(`Directory ${pc.cyan(args.name)} already exists`);
+        return;
+      }
+    }
+
+    // Interactive prompts
+    const response = await prompts(
+      [
+        {
+          type: args.name ? null : 'text',
+          name: 'name',
+          message: 'Project name:',
+          initial: 'my-a3-app',
+          validate: (value: string) => {
+            if (!value) return 'Project name is required';
+            if (!/^[a-z0-9-_]+$/i.test(value)) {
+              return 'Project name can only contain letters, numbers, dashes, and underscores';
+            }
+            const targetDir = resolve(process.cwd(), value);
+            if (existsSync(targetDir)) {
+              return `Directory ${value} already exists`;
+            }
+            return true;
+          },
+        },
+        {
+          type: args.template ? null : 'select',
+          name: 'template',
+          message: 'Select a template:',
+          choices: templates.map((t) => ({
+            title: `${t.displayName}`,
+            description: t.description,
+            value: t.name,
+          })),
+        },
+        {
+          type: 'confirm',
+          name: 'git',
+          message: 'Initialize git repository?',
+          initial: true,
+        },
+        {
+          type: 'confirm',
+          name: 'install',
+          message: 'Install dependencies?',
+          initial: true,
+        },
+      ],
+      {
+        onCancel: () => {
+          consola.info('Cancelled');
+          process.exit(0);
+        },
+      }
+    );
+
+    const projectName = args.name || response.name;
+    const template = args.template || response.template;
+    const shouldInitGit = args.git !== false && response.git !== false;
+    const shouldInstall = args.install !== false && response.install !== false;
+
+    if (!projectName || !template) {
+      consola.error('Missing required options');
+      return;
+    }
+
+    const targetDir = resolve(process.cwd(), projectName);
+
+    console.log('');
+    consola.start(`Creating ${pc.cyan(projectName)} with ${pc.green(template)} template...`);
+
+    // Download template
+    try {
+      await downloadTemplate(template, targetDir);
+      consola.success('Downloaded template');
+    } catch (error) {
+      consola.error(`Failed to download template: ${error}`);
+      return;
+    }
+
+    // Process template (replace placeholders)
+    try {
+      await processTemplate(targetDir, { projectName });
+      consola.success('Processed template');
+    } catch (error) {
+      consola.error(`Failed to process template: ${error}`);
+      return;
+    }
+
+    // Initialize git
+    if (shouldInitGit) {
+      const gitInstalled = await isGitInstalled();
+      if (gitInstalled) {
+        try {
+          await initGit(targetDir);
+          consola.success('Initialized git repository');
+        } catch (error) {
+          consola.warn(`Failed to initialize git: ${error}`);
+        }
+      } else {
+        consola.warn('Git is not installed, skipping git initialization');
+      }
+    }
+
+    // Install dependencies
+    if (shouldInstall) {
+      try {
+        await installDependencies(targetDir);
+        consola.success('Installed dependencies');
+      } catch (error) {
+        consola.warn(`Failed to install dependencies: ${error}`);
+        consola.info('You can install them manually with: bun install');
+      }
+    }
+
+    // Print success message
+    console.log('');
+    consola.box({
+      title: pc.green('Success!'),
+      message: `Project ${pc.cyan(projectName)} created successfully`,
+      style: {
+        borderColor: 'green',
+      },
+    });
+
+    console.log('');
+    consola.info(`${pc.bold('Next steps:')}`);
+    console.log('');
+    console.log(`  ${pc.cyan('cd')} ${projectName}`);
+
+    if (!shouldInstall) {
+      console.log(`  ${pc.cyan('bun install')}`);
+    }
+
+    console.log(`  ${pc.cyan('bun run scripts/setup-project.ts')}  ${pc.dim('# Configure environment')}`);
+    console.log(`  ${pc.cyan('bun run dev')}`);
+    console.log('');
+    consola.info(`Visit ${pc.cyan('http://localhost:5173')} to see your app`);
+    console.log('');
+  },
+});

package/src/commands/index.ts

@@ -0,0 +1,2 @@
+export { createCommand } from './create';
+export { templatesCommand } from './templates';

package/src/commands/templates.ts

@@ -0,0 +1,32 @@
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import pc from 'picocolors';
+import { listTemplates } from '../lib/template';
+
+export const templatesCommand = defineCommand({
+  meta: {
+    name: 'templates',
+    description: 'List available templates',
+  },
+  async run() {
+    console.log('');
+    consola.info(`${pc.bold('Available templates:')}`);
+    console.log('');
+
+    const templates = await listTemplates();
+
+    for (const template of templates) {
+      console.log(`  ${pc.cyan(pc.bold(template.name))} - ${template.displayName}`);
+      console.log(`    ${pc.dim(template.description)}`);
+      console.log('');
+      console.log(`    ${pc.dim('Features:')}`);
+      for (const feature of template.features) {
+        console.log(`      ${pc.dim('•')} ${feature}`);
+      }
+      console.log('');
+    }
+
+    consola.info(`Create a project with: ${pc.cyan('a3 create my-app --template kysely')}`);
+    console.log('');
+  },
+});

package/src/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { defineCommand, runMain } from 'citty';
+import { createCommand } from './commands/create';
+import { templatesCommand } from './commands/templates';
+
+const main = defineCommand({
+  meta: {
+    name: 'a3',
+    version: '0.1.0',
+    description: 'A3 Stack CLI - Create modern full-stack apps with SvelteKit, Better Auth, and Kysely',
+  },
+  subCommands: {
+    create: createCommand,
+    templates: templatesCommand,
+  },
+});
+
+runMain(main);

package/src/lib/git.ts

@@ -0,0 +1,34 @@
+import { $ } from 'bun';
+
+/**
+ * Check if git is installed
+ */
+export async function isGitInstalled(): Promise<boolean> {
+  try {
+    await $`git --version`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initialize a git repository
+ */
+export async function initGit(dir: string): Promise<void> {
+  await $`git init`.cwd(dir).quiet();
+  await $`git add -A`.cwd(dir).quiet();
+  await $`git commit -m "Initial commit from a3-cli"`.cwd(dir).quiet();
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+export async function isGitRepo(dir: string): Promise<boolean> {
+  try {
+    await $`git rev-parse --is-inside-work-tree`.cwd(dir).quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/lib/index.ts

@@ -0,0 +1,4 @@
+// Re-export all library functions for use as a module
+export * from './template';
+export * from './git';
+export * from './setup';

package/src/lib/setup.ts

@@ -0,0 +1,45 @@
+import { $ } from 'bun';
+import consola from 'consola';
+
+/**
+ * Install dependencies using bun
+ */
+export async function installDependencies(dir: string): Promise<void> {
+  consola.start('Installing dependencies...');
+  await $`bun install`.cwd(dir);
+}
+
+/**
+ * Run post-install script if it exists
+ */
+export async function runPostInstall(dir: string, script?: string): Promise<void> {
+  if (!script) {
+    // Default to running setup-project.ts
+    script = 'bun run scripts/setup-project.ts';
+  }
+
+  try {
+    consola.start('Running post-install setup...');
+    const [cmd, ...args] = script.split(' ');
+    await $`${cmd} ${args}`.cwd(dir);
+    consola.success('Post-install setup complete');
+  } catch (error) {
+    // Post-install is optional
+    consola.warn('Post-install script failed or not found');
+  }
+}
+
+/**
+ * Detect the preferred package manager
+ */
+export function detectPackageManager(): 'bun' | 'npm' | 'pnpm' | 'yarn' {
+  // Check for bun.lockb
+  const userAgent = process.env.npm_config_user_agent || '';
+
+  if (userAgent.includes('bun')) return 'bun';
+  if (userAgent.includes('pnpm')) return 'pnpm';
+  if (userAgent.includes('yarn')) return 'yarn';
+
+  // Default to bun for this CLI
+  return 'bun';
+}

package/src/lib/template.ts

@@ -0,0 +1,115 @@
+import { downloadTemplate as gigetDownload } from 'giget';
+import { join } from 'path';
+import { readFile, writeFile, readdir } from 'fs/promises';
+
+export interface Template {
+  name: string;
+  displayName: string;
+  description: string;
+  features: string[];
+  icon: string;
+  version: string;
+  postInstall?: string;
+}
+
+export interface TemplateVariables {
+  projectName: string;
+  [key: string]: string;
+}
+
+const GITHUB_REPO = 'AdamAugustinsky/a3-stack';
+
+/**
+ * List available templates
+ * TODO: In the future, fetch this from the GitHub API
+ */
+export async function listTemplates(): Promise<Template[]> {
+  return [
+    {
+      name: 'kysely',
+      displayName: 'A3 Stack + Kysely',
+      description: 'SvelteKit 5 + Better Auth + Kysely with PostgreSQL',
+      features: [
+        'Type-safe SQL with Kysely',
+        'PostgreSQL with Docker',
+        'Better Auth authentication',
+        'Organization/multi-tenant support',
+        'shadcn-svelte components',
+        'TailwindCSS v4',
+        'Remote functions (experimental)',
+        'Atlas database migrations',
+      ],
+      icon: 'database',
+      version: '1.0.0',
+      postInstall: 'bun run scripts/setup-project.ts',
+    },
+  ];
+}
+
+/**
+ * Download a template from GitHub
+ */
+export async function downloadTemplate(
+  templateName: string,
+  targetDir: string
+): Promise<void> {
+  await gigetDownload(`github:${GITHUB_REPO}/templates/${templateName}`, {
+    dir: targetDir,
+    force: false,
+  });
+}
+
+/**
+ * Process template by replacing placeholders
+ */
+export async function processTemplate(
+  dir: string,
+  variables: TemplateVariables
+): Promise<void> {
+  // Update package.json name
+  const pkgPath = join(dir, 'package.json');
+  let pkgContent = await readFile(pkgPath, 'utf-8');
+
+  // Replace all template variables
+  for (const [key, value] of Object.entries(variables)) {
+    const placeholder = `{{${key}}}`;
+    pkgContent = pkgContent.replace(new RegExp(placeholder, 'g'), value);
+  }
+
+  await writeFile(pkgPath, pkgContent);
+
+  // Remove template.json if it exists
+  try {
+    const { unlink } = await import('fs/promises');
+    await unlink(join(dir, 'template.json'));
+  } catch {
+    // template.json might not exist, that's fine
+  }
+
+  // Remove .claude directory if it exists (AI assistant specific configs)
+  try {
+    const { rm } = await import('fs/promises');
+    await rm(join(dir, '.claude'), { recursive: true, force: true });
+  } catch {
+    // .claude might not exist, that's fine
+  }
+
+  // Remove CLAUDE.md, AGENTS.md if they exist
+  const filesToRemove = ['CLAUDE.md', 'AGENTS.md', 'SVELTE5-BOUNDARY-REFACTOR-GUIDE.md'];
+  for (const file of filesToRemove) {
+    try {
+      const { unlink } = await import('fs/promises');
+      await unlink(join(dir, file));
+    } catch {
+      // File might not exist, that's fine
+    }
+  }
+}
+
+/**
+ * Get template metadata
+ */
+export async function getTemplateInfo(templateName: string): Promise<Template | null> {
+  const templates = await listTemplates();
+  return templates.find((t) => t.name === templateName) || null;
+}