task-o-matic-core 0.1.0

package/src/lib/bootstrap/cli-bootstrap.ts

@@ -0,0 +1,397 @@
+import { exec } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import type { CliDependencyLevel } from "../../types";
+import { logger } from "../logger";
+
+const execAsync = promisify(exec);
+
+export interface CliBootstrapOptions {
+  projectName: string;
+  projectPath: string;
+  dependencyLevel: CliDependencyLevel;
+  packageManager: "npm" | "pnpm" | "bun";
+  runtime: "node" | "bun";
+  typescript: boolean;
+}
+
+export async function bootstrapCliProject(
+  options: CliBootstrapOptions
+): Promise<{ success: boolean; message: string }> {
+  try {
+    logger.info(`\n🚀 Bootstrapping CLI project: ${options.projectName}`);
+
+    // Create project directory
+    if (!existsSync(options.projectPath)) {
+      mkdirSync(options.projectPath, { recursive: true });
+      logger.success(`  ✓ Created project directory`);
+    }
+
+    // Create directory structure
+    const dirs = [
+      "src/cli",
+      "src/commands",
+      "src/types",
+    ];
+
+    // Add services dir for standard+
+    if (options.dependencyLevel !== "minimal") {
+      dirs.push("src/services");
+    }
+
+    // Add test dir for full+
+    if (options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic") {
+      dirs.push("src/test");
+    }
+
+    for (const dir of dirs) {
+      const fullPath = join(options.projectPath, dir);
+      mkdirSync(fullPath, { recursive: true });
+    }
+    logger.success(`  ✓ Created directory structure`);
+
+    // Generate files
+    writeFileSync(
+      join(options.projectPath, "package.json"),
+      generatePackageJson(options)
+    );
+    logger.success(`  ✓ Created package.json`);
+
+    writeFileSync(
+      join(options.projectPath, "tsconfig.json"),
+      generateTsConfig(options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic")
+    );
+    logger.success(`  ✓ Created tsconfig.json`);
+
+    writeFileSync(
+      join(options.projectPath, "src/cli/bin.ts"),
+      generateBinTemplate()
+    );
+    logger.success(`  ✓ Created src/cli/bin.ts`);
+
+    writeFileSync(
+      join(options.projectPath, "src/index.ts"),
+      generateIndexTemplate(options.projectName)
+    );
+    logger.success(`  ✓ Created src/index.ts`);
+
+    writeFileSync(
+      join(options.projectPath, "src/commands/index.ts"),
+      generateCommandsIndexTemplate()
+    );
+    logger.success(`  ✓ Created src/commands/index.ts`);
+
+    writeFileSync(
+      join(options.projectPath, "src/commands/example.ts"),
+      generateExampleCommandTemplate()
+    );
+    logger.success(`  ✓ Created src/commands/example.ts`);
+
+    writeFileSync(
+      join(options.projectPath, "src/types/index.ts"),
+      generateTypesTemplate()
+    );
+    logger.success(`  ✓ Created src/types/index.ts`);
+
+    writeFileSync(
+      join(options.projectPath, "README.md"),
+      generateReadmeTemplate(options)
+    );
+    logger.success(`  ✓ Created README.md`);
+
+    writeFileSync(
+      join(options.projectPath, ".gitignore"),
+      generateGitignoreTemplate()
+    );
+    logger.success(`  ✓ Created .gitignore`);
+
+    // Install dependencies
+    logger.progress(`\n  📦 Installing dependencies with ${options.packageManager}...`);
+    const installCmd = options.packageManager === "npm" ? "npm install" :
+                      options.packageManager === "pnpm" ? "pnpm install" :
+                      "bun install";
+
+    await execAsync(installCmd, { cwd: options.projectPath });
+    logger.success(`  ✓ Dependencies installed`);
+
+    return {
+      success: true,
+      message: `CLI project "${options.projectName}" created successfully!`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to bootstrap CLI project: ${message}`
+    };
+  }
+}
+
+function generatePackageJson(options: CliBootstrapOptions): string {
+  const deps = getBaseDependencies(options.dependencyLevel);
+  const devDeps = getDevDependencies(options);
+  const scripts = getScripts(options);
+
+  const pkg = {
+    name: options.projectName,
+    version: "0.1.0",
+    type: "module",
+    main: "./dist/lib/index.js",
+    types: "./dist/lib/index.d.ts",
+    bin: {
+      [options.projectName]: "./dist/cli/bin.js"
+    },
+    scripts,
+    dependencies: deps,
+    devDependencies: devDeps,
+  };
+
+  return JSON.stringify(pkg, null, 2);
+}
+
+function getBaseDependencies(level: CliDependencyLevel): Record<string, string> {
+  const deps: Record<string, Record<string, string>> = {
+    minimal: {
+      commander: "latest",
+      chalk: "latest"
+    },
+    standard: {
+      commander: "latest",
+      chalk: "latest",
+      inquirer: "latest",
+      dotenv: "latest"
+    },
+    full: {
+      commander: "latest",
+      chalk: "latest",
+      inquirer: "latest",
+      dotenv: "latest"
+    },
+    "task-o-matic": {
+      commander: "latest",
+      chalk: "latest",
+      inquirer: "latest",
+      dotenv: "latest",
+      ai: "latest",
+      "@ai-sdk/anthropic": "latest",
+      "@ai-sdk/openai": "latest",
+      zod: "latest"
+    }
+  };
+
+  return deps[level];
+}
+
+function getDevDependencies(options: CliBootstrapOptions): Record<string, string> {
+  const devDeps: Record<string, string> = {
+    typescript: "latest",
+    "@types/node": "latest",
+  };
+
+  if (options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic") {
+    devDeps.mocha = "latest";
+    devDeps.tsx = "latest";
+    devDeps["@types/mocha"] = "latest";
+  }
+
+  return devDeps;
+}
+
+function getScripts(options: CliBootstrapOptions): Record<string, string> {
+  const scripts: Record<string, string> = {
+    build: "rm -rf dist && tsc",
+    "build:watch": "tsc --watch",
+    dev: "tsx src/cli/bin.ts",
+    start: "node dist/cli/bin.js",
+    "check-types": "tsc --noEmit"
+  };
+
+  if (options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic") {
+    scripts.test = "mocha -r tsx/cjs src/test/**/*.test.ts";
+  }
+
+  return scripts;
+}
+
+function generateBinTemplate(): string {
+  return `#!/usr/bin/env node
+import { runCLI } from "../index.js";
+
+runCLI().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+`;
+}
+
+function generateIndexTemplate(projectName: string): string {
+  return `import { Command } from "commander";
+import chalk from "chalk";
+import { exampleCommand } from "./commands/example.js";
+
+const program = new Command();
+
+program
+  .name("${projectName}")
+  .description("CLI application generated by task-o-matic")
+  .version("0.1.0");
+
+program.addCommand(exampleCommand);
+
+program.action(() => {
+  console.log(chalk.blue("Welcome to ${projectName}!"));
+  console.log(chalk.gray("Run with --help to see available commands"));
+});
+
+export const runCLI = async () => {
+  await program.parseAsync(process.argv);
+};
+`;
+}
+
+function generateCommandsIndexTemplate(): string {
+  return `export * from "./example.js";
+`;
+}
+
+function generateExampleCommandTemplate(): string {
+  return `import { Command } from "commander";
+import chalk from "chalk";
+
+export const exampleCommand = new Command("hello")
+  .description("Example command that greets the user")
+  .argument("[name]", "Name to greet", "World")
+  .action((name: string) => {
+    console.log(chalk.green(\`Hello, \${name}!\`));
+  });
+`;
+}
+
+function generateTypesTemplate(): string {
+  return `// Add your custom types here
+
+export interface ExampleType {
+  name: string;
+  value: number;
+}
+`;
+}
+
+function generateTsConfig(strict: boolean): string {
+  const config = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: strict,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      declaration: true,
+      declarationMap: true,
+      outDir: "dist",
+      rootDir: "src",
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+
+  return JSON.stringify(config, null, 2);
+}
+
+function generateReadmeTemplate(options: CliBootstrapOptions): string {
+  return `# ${options.projectName}
+
+CLI application generated by task-o-matic
+
+## Installation
+
+\`\`\`bash
+${options.packageManager} install
+\`\`\`
+
+## Development
+
+\`\`\`bash
+# Run in development mode
+${options.packageManager} run dev
+
+# Build the project
+${options.packageManager} run build
+
+# Run the built CLI
+${options.packageManager} start
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+${options.projectName} --help
+${options.projectName} hello World
+\`\`\`
+
+## Project Structure
+
+- \`src/cli/bin.ts\` - CLI entry point
+- \`src/index.ts\` - Main CLI setup with Commander.js
+- \`src/commands/\` - Command implementations
+- \`src/types/\` - TypeScript type definitions
+${options.dependencyLevel !== "minimal" ? "- `src/services/` - Business logic services\n" : ""}${(options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic") ? "- `src/test/` - Test files\n" : ""}
+## Dependencies
+
+This project uses:
+- **Commander.js** - CLI framework
+- **Chalk** - Terminal string styling
+${options.dependencyLevel !== "minimal" ? "- **Inquirer** - Interactive CLI prompts\n- **Dotenv** - Environment variable management\n" : ""}${options.dependencyLevel === "task-o-matic" ? "- **Vercel AI SDK** - AI integration\n- **Zod** - Runtime type validation\n" : ""}
+## Scripts
+
+- \`${options.packageManager} run build\` - Build the TypeScript project
+- \`${options.packageManager} run dev\` - Run in development mode with tsx
+- \`${options.packageManager} start\` - Run the built CLI
+- \`${options.packageManager} run check-types\` - Type check without compilation
+${(options.dependencyLevel === "full" || options.dependencyLevel === "task-o-matic") ? `- \`${options.packageManager} test\` - Run tests with Mocha\n` : ""}
+---
+
+Generated with [task-o-matic](https://github.com/anthropics/task-o-matic)
+`;
+}
+
+function generateGitignoreTemplate(): string {
+  return `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Testing
+coverage/
+
+# Production
+dist/
+build/
+
+# Misc
+.DS_Store
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# TypeScript
+*.tsbuildinfo
+`;
+}

package/src/lib/bootstrap/index.ts

@@ -0,0 +1,2 @@
+export * from "./cli-bootstrap.js";
+export * from "./medusa-bootstrap.js";

package/src/lib/bootstrap/medusa-bootstrap.ts

@@ -0,0 +1,261 @@
+import { exec } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { logger } from "../logger";
+
+const execAsync = promisify(exec);
+
+export interface MedusaBootstrapOptions {
+  projectName: string;
+  projectPath: string;
+  packageManager: "npm" | "pnpm" | "bun";
+  database?: "postgres" | "sqlite";
+  skipDb?: boolean;
+  skipInstall?: boolean;
+  version?: string;
+}
+
+export async function bootstrapMedusaProject(
+  options: MedusaBootstrapOptions
+): Promise<{ success: boolean; message: string }> {
+  try {
+    logger.info(
+      `\n🚀 Bootstrapping MedusaJS project: ${options.projectName}`
+    );
+
+    // Create project directory
+    if (!existsSync(options.projectPath)) {
+      mkdirSync(options.projectPath, { recursive: true });
+      logger.success(`  ✓ Created project directory`);
+    }
+
+    // Build create-medusa-app command with correct package runner
+    const versionFlag = options.version ? `@${options.version}` : "@latest";
+    const dbFlag =
+      options.database === "postgres"
+        ? "--db-type postgres"
+        : "--db-type sqlite";
+    const skipInstallFlag = options.skipInstall ? "--skip-install" : "";
+
+    // Respect package manager for the runner
+    const packageRunner =
+      options.packageManager === "npm"
+        ? "npx"
+        : options.packageManager === "pnpm"
+        ? "pnpm dlx"
+        : "bunx";
+
+    // Use the project path as the target directory
+    const createCmd = `${packageRunner} create-medusa-app${versionFlag} ${options.projectPath} ${dbFlag} ${skipInstallFlag} --skip-db --no-browser`;
+
+    logger.progress(
+      `\n  📦 Running create-medusa-app with ${options.packageManager}...`
+    );
+    await execAsync(createCmd, { cwd: process.cwd() });
+    logger.success(`  ✓ MedusaJS project scaffolded`);
+
+    // Generate environment file
+    const envContent = generateEnvFile(options);
+    writeFileSync(join(options.projectPath, ".env"), envContent);
+    logger.success(`  ✓ Created .env file`);
+
+    // Generate README
+    const readmeContent = generateReadme(options);
+    writeFileSync(join(options.projectPath, "README.md"), readmeContent);
+    logger.success(`  ✓ Created README.md`);
+
+    // Install dependencies if not skipped
+    if (!options.skipInstall) {
+      logger.progress(
+        `\n  📦 Installing dependencies with ${options.packageManager}...`
+      );
+      const installCmd =
+        options.packageManager === "npm"
+          ? "npm install"
+          : options.packageManager === "pnpm"
+          ? "pnpm install"
+          : "bun install";
+
+      await execAsync(installCmd, { cwd: options.projectPath });
+      logger.success(`  ✓ Dependencies installed`);
+    }
+
+    // Setup database if not skipped
+    if (!options.skipDb) {
+      logger.progress(`\n  🗄️  Setting up database...`);
+      try {
+        const dbPackageRunner =
+          options.packageManager === "npm"
+            ? "npx"
+            : options.packageManager === "pnpm"
+            ? "pnpm dlx"
+            : "bunx";
+        await execAsync(`${dbPackageRunner} medusa db:setup`, {
+          cwd: options.projectPath,
+        });
+        logger.success(`  ✓ Database setup complete`);
+      } catch (_error) {
+        const dbPackageRunner =
+          options.packageManager === "npm"
+            ? "npx"
+            : options.packageManager === "pnpm"
+            ? "pnpm dlx"
+            : "bunx";
+        logger.warn(
+          `  ⚠️  Database setup skipped (run '${dbPackageRunner} medusa db:setup' manually)`
+        );
+      }
+    }
+
+    return {
+      success: true,
+      message: `MedusaJS project "${options.projectName}" created successfully!`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to bootstrap MedusaJS project: ${message}`,
+    };
+  }
+}
+
+function generateEnvFile(options: MedusaBootstrapOptions): string {
+  const database = options.database || "sqlite";
+  const databaseUrl =
+    database === "postgres"
+      ? "postgres://postgres:postgres@localhost:5432/medusa-store"
+      : "sqlite://./medusa.db";
+
+  // Generate secure random secrets
+  const jwtSecret = randomBytes(32).toString("hex");
+  const cookieSecret = randomBytes(32).toString("hex");
+
+  return `# Database Configuration
+DATABASE_URL=${databaseUrl}
+
+# Authentication Secrets (auto-generated)
+JWT_SECRET=${jwtSecret}
+COOKIE_SECRET=${cookieSecret}
+
+# CORS Configuration (adjust for your frontend)
+STORE_CORS=http://localhost:8000
+ADMIN_CORS=http://localhost:7001,http://localhost:7000
+
+# Server Configuration
+PORT=9000
+
+# Redis (optional - uncomment for production)
+# REDIS_URL=redis://localhost:6379
+
+# Worker Mode (shared = single process, server = API only, worker = background jobs only)
+WORKER_MODE=shared
+`;
+}
+
+function generateReadme(options: MedusaBootstrapOptions): string {
+  const database = options.database || "sqlite";
+
+  return `# ${options.projectName}
+
+MedusaJS e-commerce backend generated by task-o-matic
+
+## Getting Started
+
+### Prerequisites
+
+${
+  database === "postgres"
+    ? `- PostgreSQL database running
+- Update \`DATABASE_URL\` in \`.env\` with your database credentials`
+    : `- SQLite (no additional setup required)`
+}
+
+### Installation
+
+\`\`\`bash
+${options.packageManager} install
+\`\`\`
+
+### Database Setup
+
+\`\`\`bash
+# Run migrations and seed data
+${
+  options.packageManager === "npm"
+    ? "npx"
+    : options.packageManager === "pnpm"
+    ? "pnpm dlx"
+    : "bunx"
+} medusa db:setup
+\`\`\`
+
+### Development
+
+\`\`\`bash
+# Start development server
+${options.packageManager} run dev
+
+# The API will be available at http://localhost:9000
+# Admin dashboard at http://localhost:9000/app
+\`\`\`
+
+### Build
+
+\`\`\`bash
+# Build for production
+${options.packageManager} run build
+
+# Start production server
+${options.packageManager} start
+\`\`\`
+
+## Project Structure
+
+- \`src/\` - Source code
+  - \`src/admin/\` - Admin dashboard customizations
+  - \`src/api/\` - API routes and middlewares
+  - \`src/modules/\` - Custom modules
+  - \`src/workflows/\` - Business logic workflows
+  - \`src/subscribers/\` - Event subscribers
+- \`medusa-config.ts\` - MedusaJS configuration
+- \`.env\` - Environment variables
+
+## Environment Variables
+
+Key environment variables (see \`.env\` for full list):
+
+- \`DATABASE_URL\` - Database connection string
+- \`JWT_SECRET\` - Secret for JWT tokens
+- \`COOKIE_SECRET\` - Secret for cookies
+- \`STORE_CORS\` - Allowed origins for storefront
+- \`ADMIN_CORS\` - Allowed origins for admin
+
+## Documentation
+
+- [MedusaJS Documentation](https://docs.medusajs.com)
+- [API Reference](https://docs.medusajs.com/api)
+- [Admin Guide](https://docs.medusajs.com/admin)
+
+## Next Steps
+
+1. Configure your database connection in \`.env\`
+2. Run \`${
+    options.packageManager === "npm"
+      ? "npx"
+      : options.packageManager === "pnpm"
+      ? "pnpm dlx"
+      : "bunx"
+  } medusa db:setup\` to initialize the database
+3. Start the development server with \`${options.packageManager} run dev\`
+4. Access the admin dashboard at http://localhost:9000/app
+5. Create your first admin user
+
+---
+
+Generated with [task-o-matic](https://github.com/DimitriGilbert/task-o-matic)
+`;
+}