task-o-matic-core 0.1.0

package/dist/lib/better-t-stack-cli.js

@@ -0,0 +1,428 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterTStackIntegration = exports.BetterTStackService = void 0;
+exports.runBetterTStackCLI = runBetterTStackCLI;
+const config_1 = require("./config");
+const fs_1 = require("fs");
+// import { glob } from "glob";
+const path_1 = require("path");
+const logger_1 = require("./logger");
+class BetterTStackService {
+    async createProject(name, config, workingDirectory) {
+        try {
+            logger_1.logger.info(`🚀 Bootstrapping Better-T-Stack project: ${name}`);
+            // Change to working directory if provided
+            const originalCwd = process.cwd();
+            if (workingDirectory) {
+                process.chdir(workingDirectory);
+                logger_1.logger.info(`🔥 Changed working directory to: ${workingDirectory}`);
+            }
+            // Convert our config to Better-T-Stack API format
+            const apiConfig = this.convertToAPIConfig(config);
+            logger_1.logger.info(`🔥 Calling Better-T-Stack programmatic API...`);
+            // Use dynamic import with eval to bypass TypeScript module resolution
+            // The module exports `init` as a named export, but depending on how it's bundled,
+            // it might be directly on the module or wrapped in a default export
+            const btsModule = await eval(`import("create-better-t-stack")`);
+            // Handle different module structures and API versions
+            // The package renamed 'init' to 'create' in a recent update
+            const initFn = btsModule.create ||
+                btsModule.init ||
+                btsModule.default?.create ||
+                btsModule.default?.init ||
+                btsModule.default;
+            if (typeof initFn !== "function") {
+                throw new Error(`Could not find 'create' or 'init' function in create-better-t-stack module. ` +
+                    `Available exports: ${Object.keys(btsModule).join(", ")}`);
+            }
+            const result = await initFn(name, apiConfig);
+            // Restore original directory
+            if (workingDirectory) {
+                process.chdir(originalCwd);
+            }
+            if (result.success) {
+                // Save configuration
+                await this.saveBTSConfig(name, config, result.projectDirectory);
+                // Post-bootstrap enhancements
+                try {
+                    const projectDir = result.projectDirectory;
+                    // 1. Add check-types script to packages
+                    await this.addCheckTypesScript(projectDir);
+                    // 2. Copy documentation if requested
+                    if (config.includeDocs) {
+                        await this.copyDocumentation(projectDir);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error(`⚠ Post-bootstrap enhancements failed: ${error}`);
+                    // Don't fail the whole process, just log warning
+                }
+                return {
+                    success: true,
+                    projectPath: result.relativePath,
+                    message: `Better-T-Stack project ${name} created successfully at ${result.projectDirectory}`,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    projectPath: "",
+                    message: `Better-T-Stack bootstrap failed: ${result.error}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                projectPath: "",
+                message: `Better-T-Stack initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+    }
+    convertToAPIConfig(config) {
+        // Ensure frontend is always an array for Better-T-Stack API
+        const frontend = Array.isArray(config.frontend)
+            ? config.frontend
+            : [config.frontend];
+        return {
+            // Don't use 'yes' flag when providing explicit configuration
+            frontend,
+            backend: config.backend,
+            runtime: config.runtime,
+            api: config.api,
+            auth: config.auth,
+            database: config.database,
+            orm: config.orm,
+            dbSetup: config.dbSetup,
+            packageManager: config.packageManager,
+            webDeploy: config.webDeploy,
+            serverDeploy: config.serverDeploy,
+            git: config.git,
+            install: config.install,
+            addons: config.addons,
+            examples: config.examples &&
+                config.examples.length > 0 &&
+                config.examples[0] !== "none"
+                ? config.examples
+                : ["none"],
+            disableAnalytics: true,
+            payments: config.payments,
+            template: config.template, // v3.13.0: mern, pern, t3, uniwind
+            // Non-interactive options (yes: true conflicts with explicit config)
+            manualDb: true, // Skip DB setup prompts
+            renderTitle: false, // Cleaner output
+        };
+    }
+    async saveBTSConfig(name, config, projectPath) {
+        const taskOMaticDir = projectPath
+            ? (0, path_1.join)(projectPath, ".task-o-matic")
+            : config_1.configManager.getTaskOMaticDir();
+        // Ensure directory exists if we're using a specific project path
+        if (projectPath && !require("fs").existsSync(taskOMaticDir)) {
+            require("fs").mkdirSync(taskOMaticDir, { recursive: true });
+        }
+        const configData = JSON.stringify({
+            ...config,
+            projectName: config.projectName || name,
+            createdAt: new Date().toISOString(),
+        }, null, 2);
+        // Save with project-specific name for tracking multiple projects
+        const namedConfigPath = (0, path_1.join)(taskOMaticDir, `${name}-bts-config.json`);
+        (0, fs_1.writeFileSync)(namedConfigPath, configData);
+        // Also save as canonical stack.json for easy discovery by context-builder
+        const stackConfigPath = (0, path_1.join)(taskOMaticDir, "stack.json");
+        (0, fs_1.writeFileSync)(stackConfigPath, configData);
+    }
+    async addCheckTypesScript(projectDir) {
+        const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+        // const { readFileSync, writeFileSync } = await import("fs");
+        logger_1.logger.info("🔍 Adding check-types scripts to packages...");
+        // Find all package.json files in apps and backend directories
+        const packageFiles = await glob(["apps/*/package.json", "backend/*/package.json"], { cwd: projectDir, absolute: true });
+        for (const file of packageFiles) {
+            try {
+                const content = JSON.parse((0, fs_1.readFileSync)(file, "utf-8"));
+                if (!content.scripts) {
+                    content.scripts = {};
+                }
+                // Add check-types script if not present
+                if (!content.scripts["check-types"]) {
+                    content.scripts["check-types"] = "tsc --noEmit";
+                    (0, fs_1.writeFileSync)(file, JSON.stringify(content, null, 2) + "\n");
+                    logger_1.logger.success(`  ✓ Added check-types to ${file.split("/").slice(-3).join("/")}`);
+                }
+            }
+            catch (err) {
+                logger_1.logger.warn(`  ⚠ Failed to update ${file}: ${err}`);
+            }
+        }
+    }
+    async copyDocumentation(projectDir) {
+        const { copyFileSync, mkdirSync, existsSync } = await Promise.resolve().then(() => __importStar(require("fs")));
+        const { resolve, dirname } = await Promise.resolve().then(() => __importStar(require("path")));
+        logger_1.logger.info("📚 Copying documentation...");
+        try {
+            // Source: docs/agents/cli.md in the current package
+            // We need to find where the package is installed or running from
+            // Assuming we are running from dist/lib/better-t-stack-cli.js or similar
+            // The docs should be in ../../docs/agents/cli.md relative to this file's location in source
+            // Or in the package root if installed
+            let sourcePath = resolve(__dirname, "../../../docs/agents/cli.md");
+            // Check if we're in dist
+            if (!existsSync(sourcePath)) {
+                // Try to find it relative to package root (cwd when running dev)
+                sourcePath = resolve(process.cwd(), "docs/agents/cli.md");
+            }
+            if (!existsSync(sourcePath)) {
+                // Try to find it in node_modules if installed as dependency
+                try {
+                    sourcePath = require.resolve("task-o-matic/docs/agents/cli.md");
+                }
+                catch (e) {
+                    // Ignore
+                }
+            }
+            if (existsSync(sourcePath)) {
+                const destPath = (0, path_1.join)(projectDir, "docs/task-o-matic.md");
+                const destDir = dirname(destPath);
+                if (!existsSync(destDir)) {
+                    mkdirSync(destDir, { recursive: true });
+                }
+                copyFileSync(sourcePath, destPath);
+                logger_1.logger.success(`  ✓ Copied documentation to docs/task-o-matic.md`);
+            }
+            else {
+                logger_1.logger.warn("  ⚠ Could not locate source documentation file");
+            }
+        }
+        catch (err) {
+            logger_1.logger.warn(`  ⚠ Failed to copy documentation: ${err}`);
+        }
+    }
+}
+exports.BetterTStackService = BetterTStackService;
+// Helper methods for multi-frontend support
+class BetterTStackIntegration {
+    btsService;
+    constructor() {
+        this.btsService = new BetterTStackService();
+    }
+    /**
+     * Parse frontend option into array of frontends
+     */
+    parseFrontends(frontendOption) {
+        if (!frontendOption)
+            return [];
+        // If already array, return it
+        if (Array.isArray(frontendOption))
+            return frontendOption;
+        // If string, split by comma or space
+        if (typeof frontendOption === "string") {
+            return frontendOption
+                .split(/[\s,]+/)
+                .map((f) => f.trim())
+                .filter(Boolean);
+        }
+        // Single value
+        return [frontendOption];
+    }
+    /**
+     * Split frontends into Better-T-Stack frontends vs custom frontends
+     */
+    splitFrontends(frontends) {
+        const customTypes = new Set(["cli", "medusa"]);
+        return {
+            btsFrontends: frontends.filter((f) => !customTypes.has(f)),
+            customFrontends: frontends.filter((f) => customTypes.has(f)),
+        };
+    }
+    /**
+     * Create project with support for multiple frontends
+     */
+    async createProject(name, options, workingDirectory) {
+        const workingDir = workingDirectory || config_1.configManager.getWorkingDirectory();
+        const frontends = this.parseFrontends(options.frontend);
+        const { btsFrontends, customFrontends } = this.splitFrontends(frontends);
+        const isMonorepo = frontends.length > 1;
+        let projectPath = (0, path_1.join)(workingDir, name);
+        const results = [];
+        try {
+            // Step 1: Bootstrap Better-T-Stack project FIRST (if any BTS frontends)
+            // This creates the monorepo structure that CLI/TUI will be added to
+            if (btsFrontends.length > 0) {
+                const result = await this.bootstrapBetterTStackProject(name, btsFrontends, options, workingDir);
+                if (!result.success)
+                    throw new Error(result.message);
+                // Get the actual project path from Better-T-Stack result
+                // This is the full path where the project was created
+                projectPath = (0, path_1.join)(workingDir, name);
+                results.push(result.message);
+            }
+            else if (isMonorepo) {
+                // Create monorepo structure manually if no BTS frontends
+                // (e.g., just cli + tui with no web/native)
+                (0, fs_1.mkdirSync)(projectPath, { recursive: true });
+                (0, fs_1.mkdirSync)((0, path_1.join)(projectPath, "apps"), { recursive: true });
+                logger_1.logger.info(`📁 Created monorepo structure at ${projectPath}`);
+            }
+            // Step 2: AFTER Better-T-Stack creates the structure, add custom frontends
+            // These get added into the apps/ directory that Better-T-Stack created
+            for (const frontend of customFrontends) {
+                if (frontend === "cli") {
+                    const result = await this.addCliToProject(name, projectPath, isMonorepo, options);
+                    results.push(result.message);
+                }
+                if (frontend === "medusa") {
+                    const result = await this.addMedusaToProject(name, projectPath, isMonorepo, options);
+                    results.push(result.message);
+                }
+            }
+            return {
+                success: true,
+                message: results.join("\n"),
+                projectPath,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                message: `Project creation failed: ${message}`,
+            };
+        }
+    }
+    /**
+     * Bootstrap Better-T-Stack project with one or more frontends
+     */
+    async bootstrapBetterTStackProject(name, frontends, options, workingDir) {
+        const backend = options.backend || "hono";
+        const isConvex = backend === "convex";
+        const btsConfig = {
+            projectName: options.name || options.projectName || name,
+            frontend: frontends.length === 1 ? frontends[0] : frontends, // Pass array if multiple
+            backend: backend || "hono",
+            database: isConvex
+                ? "none"
+                : options.database || "sqlite",
+            auth: options.noAuth
+                ? "none"
+                : options.auth || "better-auth",
+            addons: options.addons || ["turborepo"],
+            runtime: (isConvex || backend === "self"
+                ? "none"
+                : options.runtime || "node"),
+            api: options.api || "none",
+            payments: options.payment || "none",
+            orm: (isConvex ? "none" : options.orm || "drizzle"),
+            dbSetup: (isConvex
+                ? "none"
+                : options.dbSetup || "none"),
+            packageManager: options.packageManager || "npm",
+            git: !options.noGit,
+            webDeploy: options.webDeploy || "none",
+            serverDeploy: options.serverDeploy || "none",
+            install: !options.noInstall,
+            examples: options.examples || ["none"],
+            template: options.template, // Optional shortcut, don't default
+            // Non-interactive options (yes: true conflicts with explicit config)
+            manualDb: true,
+            renderTitle: false,
+            includeDocs: options.includeDocs,
+        };
+        const result = await this.btsService.createProject(name, btsConfig, workingDir);
+        return {
+            success: result.success,
+            message: result.message,
+            projectPath: result.projectPath,
+        };
+    }
+    /**
+     * Add CLI app to project (standalone or monorepo)
+     */
+    async addCliToProject(projectName, projectPath, isMonorepo, options) {
+        const { bootstrapCliProject } = await Promise.resolve().then(() => __importStar(require("./bootstrap/cli-bootstrap.js")));
+        const cliPath = isMonorepo ? (0, path_1.join)(projectPath, "apps", "cli") : projectPath;
+        const cliName = isMonorepo ? `${projectName}-cli` : projectName;
+        const result = await bootstrapCliProject({
+            projectName: cliName,
+            projectPath: cliPath,
+            dependencyLevel: options.cliDeps || "standard",
+            packageManager: options.packageManager || "npm",
+            runtime: options.runtime || "node",
+            typescript: true,
+        });
+        if (!result.success)
+            throw new Error(result.message);
+        return {
+            success: true,
+            message: isMonorepo
+                ? `✅ CLI app added to apps/cli/`
+                : `✅ CLI project "${projectName}" created successfully!`,
+        };
+    }
+    /**
+     * Add MedusaJS app to project (standalone or monorepo)
+     */
+    async addMedusaToProject(projectName, projectPath, isMonorepo, options) {
+        const { bootstrapMedusaProject } = await Promise.resolve().then(() => __importStar(require("./bootstrap/medusa-bootstrap.js")));
+        const medusaPath = isMonorepo
+            ? (0, path_1.join)(projectPath, "apps", "medusa")
+            : projectPath;
+        const medusaName = isMonorepo ? `${projectName}-medusa` : projectName;
+        const result = await bootstrapMedusaProject({
+            projectName: medusaName,
+            projectPath: medusaPath,
+            packageManager: options.packageManager || "npm",
+            database: options.database || "sqlite",
+            skipDb: options.noInstall, // Skip DB setup if not installing deps
+            skipInstall: options.noInstall,
+        });
+        if (!result.success)
+            throw new Error(result.message);
+        return {
+            success: true,
+            message: isMonorepo
+                ? `✅ MedusaJS app added to apps/medusa/`
+                : `✅ MedusaJS project "${projectName}" created successfully!`,
+        };
+    }
+}
+exports.BetterTStackIntegration = BetterTStackIntegration;
+// Export backward-compatible function
+async function runBetterTStackCLI(options, workingDirectory) {
+    const integration = new BetterTStackIntegration();
+    return integration.createProject(options.projectName || options.name || "default-project", options, workingDirectory);
+}

package/dist/lib/bootstrap/cli-bootstrap.d.ts

@@ -0,0 +1,14 @@
+import type { CliDependencyLevel } from "../../types";
+export interface CliBootstrapOptions {
+    projectName: string;
+    projectPath: string;
+    dependencyLevel: CliDependencyLevel;
+    packageManager: "npm" | "pnpm" | "bun";
+    runtime: "node" | "bun";
+    typescript: boolean;
+}
+export declare function bootstrapCliProject(options: CliBootstrapOptions): Promise<{
+    success: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=cli-bootstrap.d.ts.map

package/dist/lib/bootstrap/cli-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-bootstrap.d.ts","sourceRoot":"","sources":["../../../src/lib/bootstrap/cli-bootstrap.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAKtD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,kBAAkB,CAAC;IACpC,cAAc,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;IACvC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CA4GhD"}