@tanstack/cta-engine 0.10.0-alpha.16 → 0.10.0-alpha.17

package/dist/add-ons.js

@@ -1,10 +1,73 @@
-export function getAllAddOns(framework, template) {
-    return framework.getAddOns().filter((a) => a.templates.includes(template));
+import { readFile } from 'node:fs/promises';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { getTemplatesRoot } from './templates.js';
+import { DEFAULT_FRAMEWORK } from './constants.js';
+import { readFileHelper } from './file-helper.js';
+function isDirectory(path) {
+    return statSync(path).isDirectory();
+}
+function findFilesRecursively(path, files) {
+    const dirFiles = readdirSync(path);
+    for (const file of dirFiles) {
+        const filePath = resolve(path, file);
+        if (isDirectory(filePath)) {
+            findFilesRecursively(filePath, files);
+        }
+        else {
+            files[filePath] = readFileHelper(filePath);
+        }
+    }
+}
+export async function getAllAddOns(framework, template) {
+    const addOns = [];
+    for (const type of ['add-on', 'example']) {
+        const addOnsBase = resolve(getTemplatesRoot(), framework, type);
+        if (!existsSync(addOnsBase)) {
+            continue;
+        }
+        for (const dir of await readdirSync(addOnsBase).filter((file) => isDirectory(resolve(addOnsBase, file)))) {
+            const filePath = resolve(addOnsBase, dir, 'info.json');
+            const fileContent = await readFile(filePath, 'utf-8');
+            const info = JSON.parse(fileContent);
+            if (!info.templates.includes(template)) {
+                continue;
+            }
+            let packageAdditions = {};
+            if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
+                packageAdditions = JSON.parse(await readFile(resolve(addOnsBase, dir, 'package.json'), 'utf-8'));
+            }
+            let readme;
+            if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
+                readme = await readFile(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
+            }
+            const absoluteFiles = {};
+            const assetsDir = resolve(addOnsBase, dir, 'assets');
+            if (existsSync(assetsDir)) {
+                await findFilesRecursively(assetsDir, absoluteFiles);
+            }
+            const files = {};
+            for (const file of Object.keys(absoluteFiles)) {
+                files[file.replace(assetsDir, '.')] = absoluteFiles[file];
+            }
+            addOns.push({
+                ...info,
+                id: dir,
+                type,
+                packageAdditions,
+                readme,
+                files,
+                deletedFiles: [],
+            });
+        }
+    }
+    return addOns;
 }
 // Turn the list of chosen add-on IDs into a final list of add-ons by resolving dependencies
 export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
     const finalAddOnIDs = new Set(chosenAddOnIDs);
-    const addOns = getAllAddOns(framework, template);
+    const addOns = await getAllAddOns(framework, template);
     for (const addOnID of finalAddOnIDs) {
         let addOn;
         const localAddOn = addOns.find((a) => a.id === addOnID);
@@ -29,6 +92,12 @@ export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
     const finalAddOns = [...finalAddOnIDs].map((id) => addOns.find((a) => a.id === id));
     return finalAddOns;
 }
+export async function listAddOns(options, { forcedMode, forcedAddOns = [], }) {
+    const addOns = await getAllAddOns(options.framework || DEFAULT_FRAMEWORK, forcedMode || options.template || 'typescript');
+    for (const addOn of addOns.filter((a) => !forcedAddOns.includes(a.id))) {
+        console.log(`${chalk.bold(addOn.id)}: ${addOn.description}`);
+    }
+}
 function loadAddOn(addOn) {
     return addOn;
 }
@@ -36,9 +105,5 @@ export async function loadRemoteAddOn(url) {
     const response = await fetch(url);
     const fileContent = await response.json();
     fileContent.id = url;
-    return {
-        ...fileContent,
-        getFiles: () => Promise.resolve(Object.keys(fileContent.files)),
-        getFileContents: (path) => Promise.resolve(fileContent.files[path]),
-    };
+    return fileContent;
 }

package/dist/{add-to-app.js → add.js}

@@ -1,14 +1,15 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync, statSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
+import chalk from 'chalk';
 import { execa, execaSync } from 'execa';
+import { cancel, confirm, intro, isCancel, log, outro, spinner, } from '@clack/prompts';
 import { CONFIG_FILE } from './constants.js';
-import { finalizeAddOns } from './add-ons.js';
-import { getFrameworkById } from './frameworks.js';
 import { createDefaultEnvironment, createMemoryEnvironment, } from './environment.js';
 import { createApp } from './create-app.js';
-import { readConfigFile, writeConfigFile } from './config-file.js';
+import { finalizeAddOns } from './add-ons.js';
 import { sortObject } from './utils.js';
+import { readConfigFile, writeConfigFile } from './config-file.js';
 function isDirectory(path) {
     return statSync(path).isDirectory();
 }
@@ -17,16 +18,10 @@ async function hasPendingGitChanges() {
     return status.stdout.length > 0;
 }
 async function createOptions(json, addOns) {
-    const framework = getFrameworkById(json.framework);
     return {
         ...json,
-        framework,
         tailwind: true,
-        addOns: true,
-        chosenAddOns: await finalizeAddOns(framework, json.mode, [
-            ...json.existingAddOns,
-            ...addOns,
-        ]),
+        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [...json.existingAddOns, ...addOns]),
     };
 }
 async function runCreateApp(options) {
@@ -39,17 +34,19 @@ async function runCreateApp(options) {
     });
     return output;
 }
-export async function addToApp(addOns, { silent = false, } = {}, environment) {
+export async function add(addOns, { silent = false, } = {}) {
     const persistedOptions = await readConfigFile(process.cwd());
     if (!persistedOptions) {
-        environment.error('There is no .cta.json file in your project.', 'This is probably because this was created with an older version of create-tsrouter-app.');
+        console.error(`${chalk.red('There is no .cta.json file in your project.')}
+
+This is probably because this was created with an older version of create-tsrouter-app.`);
         return;
     }
     if (!silent) {
-        environment.intro(`Adding ${addOns.join(', ')} to the project...`);
+        intro(`Adding ${addOns.join(', ')} to the project...`);
     }
     if (await hasPendingGitChanges()) {
-        environment.error('You have pending git changes.', 'Please commit or stash them before adding add-ons.');
+        log.error(`${chalk.red('You have pending git changes.')} Please commit or stash them before adding add-ons.`);
         return;
     }
     const newOptions = await createOptions(persistedOptions, addOns);
@@ -75,9 +72,12 @@ export async function addToApp(addOns, { silent = false, } = {}, environment) {
         }
     }
     if (overwrittenFiles.length > 0 && !silent) {
-        environment.warn('The following will be overwritten:', overwrittenFiles.join('\n'));
-        const shouldContinue = await environment.confirm('Do you want to continue?');
-        if (!shouldContinue) {
+        log.warn(`${chalk.yellow('The following will be overwritten:')}\n${overwrittenFiles.join('\n')}`);
+        const shouldContinue = await confirm({
+            message: 'Do you want to continue?',
+        });
+        if (isCancel(shouldContinue)) {
+            cancel('Operation cancelled.');
             process.exit(0);
         }
     }
@@ -115,11 +115,11 @@ export async function addToApp(addOns, { silent = false, } = {}, environment) {
     }
     const realEnvironment = createDefaultEnvironment();
     writeConfigFile(realEnvironment, process.cwd(), newOptions);
-    const s = silent ? null : environment.spinner();
+    const s = silent ? null : spinner();
     s?.start(`Installing dependencies via ${newOptions.packageManager}...`);
     await realEnvironment.execute(newOptions.packageManager, ['install'], resolve(process.cwd()));
     s?.stop(`Installed dependencies`);
     if (!silent) {
-        environment.outro('Add-ons added successfully!');
+        outro('Add-ons added successfully!');
     }
 }

package/dist/cli.js

@@ -0,0 +1,125 @@
+import { Command, InvalidArgumentError } from 'commander';
+import { intro, log } from '@clack/prompts';
+import { createApp } from './create-app.js';
+import { normalizeOptions, promptForOptions } from './options.js';
+import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
+import { SUPPORTED_TOOLCHAINS } from './toolchain.js';
+import runServer from './mcp.js';
+import { listAddOns } from './add-ons.js';
+import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
+// import { initAddOn } from './custom-add-on.js'
+import { createDefaultEnvironment } from './environment.js';
+export function cli({ name, appName, forcedMode, forcedAddOns, }) {
+    const program = new Command();
+    program.name(name).description(`CLI to create a new ${appName} application`);
+    // program
+    //   .command('add')
+    //   .argument('add-on', 'Name of the add-on (or add-ons separated by commas)')
+    //   .action(async (addOn: string) => {
+    //     await add(addOn.split(',').map((addon) => addon.trim()))
+    //   })
+    // program
+    //   .command('update-add-on')
+    //   .description('Create or update an add-on from the current project')
+    //   .action(async () => {
+    //     await initAddOn('add-on')
+    //   })
+    // program
+    //   .command('update-overlay')
+    //   .description('Create or update a project overlay from the current project')
+    //   .action(async () => {
+    //     await initAddOn('overlay')
+    //   })
+    program.argument('[project-name]', 'name of the project');
+    if (!forcedMode) {
+        program.option('--template <type>', 'project template (typescript, javascript, file-router)', (value) => {
+            if (value !== 'typescript' &&
+                value !== 'javascript' &&
+                value !== 'file-router') {
+                throw new InvalidArgumentError(`Invalid template: ${value}. Only the following are allowed: typescript, javascript, file-router`);
+            }
+            return value;
+        });
+    }
+    program
+        .option('--framework <type>', 'project framework (solid, react)', (value) => {
+        if (!SUPPORTED_FRAMEWORKS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid framework: ${value}. Only the following are allowed: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
+        }
+        return value;
+    }, DEFAULT_FRAMEWORK)
+        // .option('--overlay [url]', 'add an overlay from a URL', false)
+        .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
+        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
+        }
+        return value;
+    })
+        .option(`--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`, `Explicitly tell the CLI to use this toolchain`, (value) => {
+        if (!SUPPORTED_TOOLCHAINS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.join(', ')}`);
+        }
+        return value;
+    })
+        .option('--tailwind', 'add Tailwind CSS', false)
+        .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
+        let addOns = !!value;
+        if (typeof value === 'string') {
+            addOns = value.split(',').map((addon) => addon.trim());
+        }
+        return addOns;
+    })
+        .option('--list-add-ons', 'list all available add-ons', false)
+        .option('--no-git', 'do not create a git repository')
+        .option('--target-dir <path>', 'the target directory for the application root')
+        .option('--mcp', 'run the MCP server', false)
+        .option('--mcp-sse', 'run the MCP server in SSE mode', false);
+    program.action(async (projectName, options) => {
+        if (options.listAddOns) {
+            await listAddOns(options, {
+                forcedMode: forcedMode,
+                forcedAddOns,
+            });
+        }
+        else if (options.mcp || options.mcpSse) {
+            await runServer(!!options.mcpSse, {
+                forcedMode: forcedMode,
+                forcedAddOns,
+                appName,
+            });
+        }
+        else {
+            try {
+                const cliOptions = {
+                    projectName,
+                    ...options,
+                };
+                if (forcedMode) {
+                    cliOptions.template = forcedMode;
+                }
+                let finalOptions = await normalizeOptions(cliOptions, forcedMode, forcedAddOns);
+                if (finalOptions) {
+                    intro(`Creating a new ${appName} app in ${projectName}...`);
+                }
+                else {
+                    intro(`Let's configure your ${appName} application`);
+                    finalOptions = await promptForOptions(cliOptions, {
+                        forcedMode: forcedMode,
+                        forcedAddOns,
+                    });
+                }
+                await createApp(finalOptions, {
+                    environment: createDefaultEnvironment(),
+                    cwd: options.targetDir || undefined,
+                    name,
+                    appName,
+                });
+            }
+            catch (error) {
+                log.error(error instanceof Error ? error.message : 'An unknown error occurred');
+                process.exit(1);
+            }
+        }
+    });
+    program.parse();
+}

package/dist/config-file.js

@@ -2,22 +2,19 @@ import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { CONFIG_FILE } from './constants.js';
 export async function writeConfigFile(environment, targetDir, options) {
-    /* eslint-disable unused-imports/no-unused-vars */
-    const { addOns, chosenAddOns, framework, ...rest } = options;
-    /* eslint-enable unused-imports/no-unused-vars */
     const persistedOptions = {
-        ...rest,
+        ...options,
         version: 1,
-        framework: options.framework.id,
         existingAddOns: options.chosenAddOns.map((addOn) => addOn.id),
     };
+    delete persistedOptions.addOns;
+    delete persistedOptions.chosenAddOns;
     await environment.writeFile(resolve(targetDir, CONFIG_FILE), JSON.stringify(persistedOptions, null, 2));
 }
 export async function readConfigFile(targetDir) {
     try {
         const configFile = resolve(targetDir, CONFIG_FILE);
         const config = await readFile(configFile, 'utf8');
-        // TODO: Look for old config files and convert them to the new format
         return JSON.parse(config);
     }
     catch {

package/dist/constants.js

@@ -1,3 +1,5 @@
 export const CODE_ROUTER = 'code-router';
 export const FILE_ROUTER = 'file-router';
+export const SUPPORTED_FRAMEWORKS = ['solid', 'react'];
+export const DEFAULT_FRAMEWORK = 'react';
 export const CONFIG_FILE = '.cta.json';