directus-template-cli 0.8.0-partials.0 → 0.8.0

package/dist/commands/apply.d.ts

@@ -50,9 +50,10 @@ export default class ApplyCommand extends BaseCommand {
     private runProgrammatic;
     /**
      * INTERACTIVE
-     * Select a local template from the given directory
-     * @param localTemplateDir - The local template directory path
+     * Select a template from the given GitHub repository
+     * @param ghTemplateUrl - The GitHub repository URL
      * @returns {Promise<Template>} - Returns the selected template
      */
+    private selectGithubTemplate;
     private selectLocalTemplate;
 }

package/dist/commands/apply.js

@@ -10,7 +10,7 @@ import * as templatePlanFlags from '../lib/template-plan/flags.js';
 import { animatedBunny } from '../lib/utils/animated-bunny.js';
 import { getDirectusEmailAndPassword, getDirectusToken, getDirectusUrl, initializeDirectusApi, } from '../lib/utils/auth.js';
 import catchError from '../lib/utils/catch-error.js';
-import { getCommunityTemplates, getGithubTemplate, getInteractiveLocalTemplate, getLocalTemplate, } from '../lib/utils/get-template.js';
+import { getCommunityTemplates, getGithubTemplate, getInteractiveGithubTemplate, getInteractiveLocalTemplate, getLocalTemplate, } from '../lib/utils/get-template.js';
 import { logger } from '../lib/utils/logger.js';
 import openUrl from '../lib/utils/open-url.js';
 import { shutdown, track } from '../services/posthog.js';
@@ -110,7 +110,7 @@ export default class ApplyCommand extends BaseCommand {
                 const ghTemplateUrl = await text({
                     message: 'What is the public GitHub repository URL?',
                 });
-                template = await getGithubTemplate(ghTemplateUrl);
+                template = await this.selectGithubTemplate(ghTemplateUrl);
                 break;
             }
             case 'local': {
@@ -267,10 +267,33 @@ export default class ApplyCommand extends BaseCommand {
     }
     /**
      * INTERACTIVE
-     * Select a local template from the given directory
-     * @param localTemplateDir - The local template directory path
+     * Select a template from the given GitHub repository
+     * @param ghTemplateUrl - The GitHub repository URL
      * @returns {Promise<Template>} - Returns the selected template
      */
+    async selectGithubTemplate(ghTemplateUrl) {
+        try {
+            const templates = await getInteractiveGithubTemplate(ghTemplateUrl);
+            if (templates.length === 1) {
+                return templates[0];
+            }
+            log.info('Multiple Directus templates found in this repository.');
+            const selectedTemplate = await select({
+                message: 'Select a template.',
+                options: templates.map(t => ({ label: t.templateName, value: t })),
+            });
+            return selectedTemplate;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                ux.error(error.message);
+            }
+            else {
+                ux.error('An unknown error occurred while getting the GitHub template.');
+            }
+            throw error;
+        }
+    }
     async selectLocalTemplate(localTemplateDir) {
         try {
             const templates = await getInteractiveLocalTemplate(localTemplateDir);
@@ -293,6 +316,7 @@ export default class ApplyCommand extends BaseCommand {
             else {
                 ux.error('An unknown error occurred while getting the local template.');
             }
+            throw error;
         }
     }
 }

package/dist/commands/init.d.ts

@@ -32,6 +32,10 @@ export default class InitCommand extends BaseCommand {
      * @returns Promise that resolves when the command is complete.
      */
     run(): Promise<void>;
+    private confirmBooleanFlag;
+    private confirmOverwriteDirectory;
+    private promptForTargetDirectory;
+    private promptForValidTemplate;
     /**
      * Interactive mode: prompts the user for each piece of info, with added template checks.
      * @param flags - The flags passed to the command.

package/dist/commands/init.js

@@ -62,76 +62,67 @@ export default class InitCommand extends BaseCommand {
      * @returns Promise that resolves when the command is complete.
      */
     async run() {
-        const { args, flags } = await this.parse(InitCommand);
+        const { args, flags, metadata } = await this.parse(InitCommand);
         const typedFlags = flags;
         const typedArgs = args;
+        const explicitFlags = {
+            gitInit: !metadata.flags.gitInit?.setFromDefault,
+            installDeps: !metadata.flags.installDeps?.setFromDefault,
+        };
         // Set the target directory and create it if it doesn't exist
         this.targetDir = path.resolve(args.directory);
-        await this.runInteractive(typedFlags, typedArgs);
+        await this.runInteractive(typedFlags, typedArgs, explicitFlags);
     }
-    /**
-     * Interactive mode: prompts the user for each piece of info, with added template checks.
-     * @param flags - The flags passed to the command.
-     * @param args - The arguments passed to the command.
-     * @returns void
-     */
-    async runInteractive(flags, args) {
-        // Show animated intro
-        await animatedBunny('Let\'s create a new Directus project!');
-        intro(`${chalk.bgHex(DIRECTUS_PURPLE).white.bold('Directus Template CLI')} - Create Project`);
-        // Check Docker availability before proceeding
-        const { createDocker } = await import('../services/docker.js');
-        const { DOCKER_CONFIG } = await import('../lib/init/config.js');
-        const dockerService = createDocker(DOCKER_CONFIG);
-        const dockerStatus = await dockerService.checkDocker();
-        if (!dockerStatus.installed || !dockerStatus.running) {
-            cancel(dockerStatus.message || 'Docker is required to initialize a Directus project.');
-            process.exit(1);
+    async confirmBooleanFlag(message) {
+        const response = await confirm({
+            initialValue: true,
+            message,
+        });
+        if (isCancel(response)) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        // Create GitHub service
-        const github = createGitHub();
-        // If no dir is provided, ask for it
-        if (!args.directory || args.directory === '.') {
-            let dirResponse = await text({
-                message: 'Enter the directory to create the project in:',
-                placeholder: './my-directus-project',
-            });
-            if (isCancel(dirResponse)) {
-                cancel('Project creation cancelled.');
-                process.exit(0);
-            }
-            // If there's no response, set a default
-            if (!dirResponse) {
-                clackLog.warn('No directory provided, using default: ./my-directus-project');
-                dirResponse = './my-directus-project';
-            }
-            this.targetDir = dirResponse;
+        return response;
+    }
+    async confirmOverwriteDirectory(flags) {
+        if (!fs.existsSync(this.targetDir) || flags.overwriteDir)
+            return Boolean(flags.overwriteDir);
+        const overwriteDirResponse = await confirm({
+            initialValue: false,
+            message: 'Directory already exists. Would you like to overwrite it?',
+        });
+        if (isCancel(overwriteDirResponse) || overwriteDirResponse === false) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        if (fs.existsSync(this.targetDir) && !flags.overwriteDir) {
-            const overwriteDirResponse = await confirm({
-                initialValue: false,
-                message: 'Directory already exists. Would you like to overwrite it?',
-            });
-            if (isCancel(overwriteDirResponse) || overwriteDirResponse === false) {
-                cancel('Project creation cancelled.');
-                process.exit(0);
-            }
-            if (overwriteDirResponse) {
-                flags.overwriteDir = true;
-            }
+        return true;
+    }
+    async promptForTargetDirectory(args) {
+        if (args.directory && args.directory !== '.')
+            return;
+        let dirResponse = await text({
+            message: 'Enter the directory to create the project in:',
+            placeholder: './my-directus-project',
+        });
+        if (isCancel(dirResponse)) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        // 1. Fetch available templates (now returns Array<{id: string, name: string, description?: string}>)
-        const availableTemplates = await github.getTemplates();
-        // 2. Prompt for template if not provided
-        let { template } = flags; // This will store the chosen template ID
-        let chosenTemplateObject;
+        // If there's no response, set a default
+        if (!dirResponse) {
+            clackLog.warn('No directory provided, using default: ./my-directus-project');
+            dirResponse = './my-directus-project';
+        }
+        this.targetDir = dirResponse;
+    }
+    async promptForValidTemplate(template, availableTemplates) {
         if (!template) {
             const templateResponse = await select({
                 message: 'Which Directus backend template would you like to use?',
                 options: availableTemplates.map(tmpl => ({
-                    hint: tmpl.description, // Show the description as a hint
-                    label: tmpl.name, // Display the friendly name
-                    value: tmpl.id, // The value submitted will be the ID (directory name)
+                    hint: tmpl.description,
+                    label: tmpl.name,
+                    value: tmpl.id,
                 })),
             });
             if (isCancel(templateResponse)) {
@@ -140,14 +131,9 @@ export default class InitCommand extends BaseCommand {
             }
             template = templateResponse;
         }
-        // Find the chosen template object for potential future use (e.g., display name later)
-        chosenTemplateObject = availableTemplates.find(t => t.id === template);
-        // 3. Validate that the template exists in the available list
-        const isDirectUrl = template?.startsWith('http');
-        // Validate against the 'id' property of the template objects
-        while (!isDirectUrl && !availableTemplates.some(t => t.id === template)) {
-            // Keep the warning message simple or refer back to the list shown in the prompt
+        while (!template.startsWith('http') && !availableTemplates.some(t => t.id === template)) {
             clackLog.warn(`Template ID "${template}" is not valid. Please choose from the list provided or enter a direct GitHub URL.`);
+            // eslint-disable-next-line no-await-in-loop
             const templateNameResponse = await text({
                 message: 'Please enter a valid template ID, a direct GitHub URL, or Ctrl+C to cancel:',
             });
@@ -156,8 +142,37 @@ export default class InitCommand extends BaseCommand {
                 process.exit(0);
             }
             template = templateNameResponse;
-            chosenTemplateObject = availableTemplates.find(t => t.id === template); // Update chosen object after re-entry
         }
+        return template;
+    }
+    /**
+     * Interactive mode: prompts the user for each piece of info, with added template checks.
+     * @param flags - The flags passed to the command.
+     * @param args - The arguments passed to the command.
+     * @returns void
+     */
+    async runInteractive(flags, args, explicitFlags) {
+        // Show animated intro
+        await animatedBunny('Let\'s create a new Directus project!');
+        intro(`${chalk.bgHex(DIRECTUS_PURPLE).white.bold('Directus Template CLI')} - Create Project`);
+        // Check Docker availability before proceeding
+        const { createDocker } = await import('../services/docker.js');
+        const { DOCKER_CONFIG } = await import('../lib/init/config.js');
+        const dockerService = createDocker(DOCKER_CONFIG);
+        const dockerStatus = await dockerService.checkDocker();
+        if (!dockerStatus.installed || !dockerStatus.running) {
+            cancel(dockerStatus.message || 'Docker is required to initialize a Directus project.');
+            process.exit(1);
+        }
+        // Create GitHub service
+        const github = createGitHub();
+        // If no dir is provided, ask for it
+        await this.promptForTargetDirectory(args);
+        const overwriteDir = await this.confirmOverwriteDirectory(flags);
+        // 1. Fetch available templates (now returns Array<{id: string, name: string, description?: string}>)
+        const availableTemplates = await github.getTemplates();
+        // 2. Prompt for template if not provided, then validate it against known templates or a direct URL.
+        const template = await this.promptForValidTemplate(flags.template, availableTemplates);
         flags.template = template; // Ensure the flag stores the ID
         // Download the template to a temporary directory to read its configuration
         const tempDir = path.join(os.tmpdir(), `directus-template-${Date.now()}`);
@@ -170,7 +185,7 @@ export default class InitCommand extends BaseCommand {
             // Read template configuration
             const templateInfo = readTemplateConfig(tempDir);
             // 4. If template has frontends and user hasn't specified a valid one, ask from the list
-            if (templateInfo?.frontendOptions.length > 0 && (!chosenFrontend || !templateInfo.frontendOptions.find(f => f.id === chosenFrontend))) {
+            if (templateInfo?.frontendOptions.length > 0 && (!chosenFrontend || !templateInfo.frontendOptions.some(f => f.id === chosenFrontend))) {
                 const frontendResponse = await select({
                     message: 'Which frontend framework do you want to use?',
                     options: templateInfo.frontendOptions.map(frontend => ({
@@ -194,24 +209,12 @@ export default class InitCommand extends BaseCommand {
                 fs.rmSync(tempDir, { force: true, recursive: true });
             }
         }
-        const installDepsResponse = await confirm({
-            initialValue: true,
-            message: 'Would you like to install project dependencies automatically?',
-        });
-        if (isCancel(installDepsResponse)) {
-            cancel('Project creation cancelled.');
-            process.exit(0);
-        }
-        const installDeps = installDepsResponse;
-        const initGitResponse = await confirm({
-            initialValue: true,
-            message: 'Initialize a new Git repository?',
-        });
-        if (isCancel(initGitResponse)) {
-            cancel('Project creation cancelled.');
-            process.exit(0);
-        }
-        const initGit = initGitResponse;
+        const installDeps = explicitFlags.installDeps
+            ? flags.installDeps ?? true
+            : await this.confirmBooleanFlag('Would you like to install project dependencies automatically?');
+        const initGit = explicitFlags.gitInit
+            ? flags.gitInit ?? true
+            : await this.confirmBooleanFlag('Initialize a new Git repository?');
         // Track the command start unless telemetry is disabled
         if (!flags.disableTelemetry) {
             await track({
@@ -235,7 +238,7 @@ export default class InitCommand extends BaseCommand {
                 frontend: chosenFrontend,
                 gitInit: initGit,
                 installDeps,
-                overwriteDir: flags.overwriteDir,
+                overwriteDir,
                 template,
             },
         });
@@ -249,7 +252,7 @@ export default class InitCommand extends BaseCommand {
                     frontend: chosenFrontend,
                     gitInit: initGit,
                     installDeps,
-                    overwriteDir: flags.overwriteDir,
+                    overwriteDir,
                     template,
                 },
                 lifecycle: 'complete',

package/dist/lib/extract/extract-content.js

@@ -1,5 +1,5 @@
 import { readCollections, readItems, readRelations } from '@directus/sdk';
-import { ux } from '@oclif/core';
+import { Errors, ux } from '@oclif/core';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
 import { getBrokenJunctionCollections, includesCollection, } from '../template-plan/index.js';
@@ -100,7 +100,6 @@ async function getDataFromCollection(collection, dir, relations, plan) {
             context: { collection, function: 'getDataFromCollection' },
             fatal: true,
         });
-        throw error;
     }
 }
 export async function extractContent(dir, plan) {
@@ -110,12 +109,15 @@ export async function extractContent(dir, plan) {
         const relations = (await api.client.request(readRelations()));
         const collections = await getCollections(relations, plan);
         for (const collection of collections) {
+            // Keep extraction sequential so the shared ux.action.status reflects the active collection.
             // eslint-disable-next-line no-await-in-loop
             const collectionWarnings = await getDataFromCollection(collection, dir, relations, plan);
             warnings.push(...collectionWarnings);
         }
     }
     catch (error) {
+        if (error instanceof Errors.CLIError)
+            throw error;
         catchError(error, {
             context: { function: 'extractContent' },
             fatal: true,

package/dist/lib/init/index.d.ts

@@ -1,4 +1,5 @@
 import { type DownloadTemplateResult } from 'giget';
+import { type PackageManager } from 'nypm';
 import type { InitFlags } from '../../commands/init.js';
 export declare function init({ dir, flags }: {
     dir: string;
@@ -8,3 +9,17 @@ export declare function init({ dir, flags }: {
     frontendDir: string;
     template: DownloadTemplateResult;
 }>;
+type DependencyInstaller = (options: {
+    cwd: string;
+    packageManager?: PackageManager;
+    silent: boolean;
+}) => Promise<unknown>;
+type InstallFrontendDependenciesOptions = {
+    frontendDir: string;
+    install?: DependencyInstaller;
+    onSkip?: () => void;
+    packageManager: null | PackageManager;
+    warn?: (message: string) => void;
+};
+export declare function installFrontendDependencies({ frontendDir, install, onSkip, packageManager, warn, }: InstallFrontendDependenciesOptions): Promise<boolean>;
+export {};

package/dist/lib/init/index.js

@@ -133,21 +133,18 @@ export async function init({ dir, flags }) {
         // Install dependencies if requested
         if (flags.installDeps) {
             const s = spinner();
+            let dependenciesInstalled = true;
             s.start('Installing dependencies');
-            try {
-                if (fs.existsSync(frontendDir)) {
-                    await installDependencies({
-                        cwd: frontendDir,
-                        packageManager,
-                        silent: true,
-                    });
-                }
+            if (fs.existsSync(frontendDir)) {
+                dependenciesInstalled = await installFrontendDependencies({
+                    frontendDir,
+                    onSkip: () => s.stop('Dependency installation skipped'),
+                    packageManager,
+                });
             }
-            catch (error) {
-                ux.warn('Failed to install dependencies');
-                throw error;
+            if (dependenciesInstalled) {
+                s.stop('Dependencies installed!');
             }
-            s.stop('Dependencies installed!');
         }
         // Initialize Git repo
         if (flags.gitInit) {
@@ -165,7 +162,7 @@ export async function init({ dir, flags }) {
             : `- Complete the onboarding form at ${pinkText(directusInfo.url || 'http://localhost:8055')} to create your admin account. \n`;
         const frontendText = flags.frontend ? `- To start the frontend, run ${pinkText(`cd ${flags.frontend}`)} and then ${pinkText(`${packageManager?.name} run dev`)}. \n` : '';
         const projectText = `- Navigate to your project directory using ${pinkText(`cd ${relativeDir}`)}. \n`;
-        const readmeText = '- Review the \`./README.md\` file for more information and next steps.';
+        const readmeText = '- Review the `./README.md` file for more information and next steps.';
         const nextSteps = `${directusText}${directusLoginText}${projectText}${frontendText}${readmeText}`;
         note(nextSteps, 'Next Steps');
         clackLog.warn(BSL_LICENSE_HEADLINE);
@@ -203,3 +200,22 @@ async function initGit(targetDir) {
         });
     }
 }
+export async function installFrontendDependencies({ frontendDir, install = installDependencies, onSkip, packageManager, warn = ux.warn, }) {
+    try {
+        await install({
+            cwd: frontendDir,
+            packageManager: packageManager ?? undefined,
+            silent: true,
+        });
+        return true;
+    }
+    catch {
+        onSkip?.();
+        warn('Failed to install dependencies');
+        if (packageManager?.name === 'pnpm') {
+            warn('This starter uses pnpm. From the frontend directory, try running: corepack enable && pnpm install');
+        }
+        warn('You can install dependencies manually and continue using the generated project.');
+        return false;
+    }
+}

package/dist/lib/load/index.js

@@ -45,7 +45,6 @@ export default async function apply(dir, flags) {
         await loadCollections(source, effectivePlan);
         await loadRelations(source, effectivePlan);
         await finalizeCollections(source, effectivePlan);
-        await finalizeFields(source, effectivePlan);
     }
     if (components.permissions || components.users) {
         await loadRoles(source);
@@ -63,6 +62,10 @@ export default async function apply(dir, flags) {
     if (components.content) {
         await loadData(source, effectivePlan);
     }
+    if (components.schema) {
+        // Finalize fields after data loading because skeleton records rely on relaxed constraints.
+        await finalizeFields(source, effectivePlan);
+    }
     if (components.dashboards) {
         await loadDashboards(source);
     }

package/dist/lib/load/load-data.d.ts

@@ -1,2 +1,3 @@
 import { type TemplatePlan } from '../template-plan/index.js';
 export default function loadData(dir: string, plan?: TemplatePlan): Promise<void>;
+export declare function getUserCollections(dir: string, plan?: TemplatePlan): any[];

package/dist/lib/load/load-data.js

@@ -26,10 +26,11 @@ function getContentCollections(dir) {
         .filter((file) => file.endsWith('.json'))
         .map((file) => path.basename(file, '.json')));
 }
-function getUserCollections(dir, plan) {
+export function getUserCollections(dir, plan) {
     const contentCollections = getContentCollections(dir);
     const collections = readFile('collections', dir);
-    const relations = plan?.partial ? readFile('relations', dir) : [];
+    const relationsPath = path.join(dir, 'relations.json');
+    const relations = plan?.partial && fs.existsSync(relationsPath) ? readFile('relations', dir) : [];
     const brokenJunctions = getBrokenJunctionCollections(relations, plan);
     if (brokenJunctions.size > 0) {
         ux.warn(`Skipping junction collections with excluded FK targets: ${[...brokenJunctions].join(', ')}`);

package/dist/lib/template-plan/metadata-plan.js

@@ -21,13 +21,16 @@ export function applyMetadataToPlan(plan, metadata) {
     for (const component of componentNames) {
         components[component] = components[component] && metadata.components[component];
     }
-    const partial = metadata.partial || componentNames.some((component) => components[component] !== plan.components[component]);
+    const partial = plan.partial ||
+        metadata.partial ||
+        componentNames.some((component) => components[component] !== plan.components[component]);
     return {
         ...plan,
         collections: intersectCollections('collections', plan.collections, metadata.collections),
         components,
         excludeCollections: mergeExcludedCollections(plan.excludeCollections, metadata.excludedCollections),
         partial,
+        relationStrategy: metadata.relationStrategy ?? plan.relationStrategy,
         schemaCollections: intersectCollections('schema collections', plan.schemaCollections, metadata.schemaCollections),
     };
 }

package/dist/lib/template-plan/metadata.js

@@ -22,16 +22,19 @@ export function readTemplateMetadata(dir) {
     const filePath = getTemplateMetadataPath(dir);
     if (!fs.existsSync(filePath))
         return undefined;
+    let metadata;
     try {
-        const metadata = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        if (metadata.version !== 2) {
-            catchError(new Error(`Unsupported template metadata version: ${metadata.version}`), { fatal: true });
-        }
-        return metadata;
+        metadata = JSON.parse(fs.readFileSync(filePath, 'utf8'));
     }
     catch (error) {
         catchError(error, { fatal: true });
+        return undefined;
+    }
+    if (metadata.version !== 2) {
+        catchError(new Error(`Unsupported template metadata version: ${metadata.version}`), { fatal: true });
+        return undefined;
     }
+    return metadata;
 }
 export async function writeTemplateMetadata(dir, plan, warnings = []) {
     const filePath = getTemplateMetadataPath(dir);

package/dist/lib/utils/get-template.d.ts

@@ -6,4 +6,5 @@ export declare function getCommunityTemplates(): Promise<Template[]>;
 export declare function getLocalTemplate(localTemplateDir: string): Promise<Template>;
 export declare function getInteractiveLocalTemplate(localTemplateDir: string): Promise<Template[]>;
 export declare function getGithubTemplate(ghTemplateUrl: string): Promise<Template>;
+export declare function getInteractiveGithubTemplate(ghTemplateUrl: string): Promise<Template[]>;
 export {};

package/dist/lib/utils/get-template.js

@@ -3,9 +3,10 @@ import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path, { dirname } from 'pathe';
 import { COMMUNITY_TEMPLATE_REPO } from '../constants.js';
+import { logger } from './logger.js';
 import resolvePathAndCheckExistence from './path.js';
 import { readAllTemplates, readTemplate } from './read-templates.js';
-import { transformGitHubUrl } from './transform-github-url.js';
+import { parseGitHubUrl, transformGitHubUrl } from './transform-github-url.js';
 // Create __dirname equivalent for ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -71,25 +72,74 @@ async function findNestedTemplates(dir, depth) {
     }
     return templates;
 }
+async function downloadGithubTemplate(ghTemplateUrl) {
+    const ghString = transformGitHubUrl(ghTemplateUrl);
+    const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'github'), false);
+    if (!downloadDir) {
+        throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'github')}`);
+    }
+    const { dir } = await downloadTemplate(ghString, {
+        dir: downloadDir,
+        force: true,
+        forceClean: true,
+    });
+    const resolvedDir = resolvePathAndCheckExistence(dir);
+    if (!resolvedDir) {
+        throw new Error(`Downloaded template directory does not exist: ${dir}`);
+    }
+    return resolvedDir;
+}
+function buildSubpathUrl(ghTemplateUrl, templatePath) {
+    const { owner, ref, repo } = parseGitHubUrl(ghTemplateUrl);
+    const normalizedPath = templatePath.split(path.sep).join('/');
+    return `https://github.com/${owner}/${repo}/tree/${ref || 'HEAD'}/${normalizedPath}`;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 export async function getGithubTemplate(ghTemplateUrl) {
     try {
-        const ghString = await transformGitHubUrl(ghTemplateUrl);
-        const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'github'), false);
-        if (!downloadDir) {
-            throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'github')}`);
+        const resolvedDir = await downloadGithubTemplate(ghTemplateUrl);
+        const template = await readTemplate(resolvedDir);
+        if (template) {
+            return template;
         }
-        const { dir } = await downloadTemplate(ghString, {
-            dir: downloadDir,
-            force: true,
-            forceClean: true,
-        });
-        const resolvedDir = resolvePathAndCheckExistence(dir);
-        if (!resolvedDir) {
-            throw new Error(`Downloaded template directory does not exist: ${dir}`);
+        const nested = await findNestedTemplates(resolvedDir, 3);
+        if (nested.length === 1) {
+            const subpath = path.relative(resolvedDir, nested[0].directoryPath);
+            const pinnedUrl = buildSubpathUrl(ghTemplateUrl, subpath);
+            logger.log('warn', `Auto-selected nested template "${nested[0].templateName}" at ${subpath}. Pin --templateLocation="${pinnedUrl}" to avoid ambiguity if more templates are added.`);
+            return nested[0];
+        }
+        if (nested.length > 1) {
+            const list = nested
+                .map(t => {
+                const subpath = path.relative(resolvedDir, t.directoryPath);
+                return `  --templateLocation="${buildSubpathUrl(ghTemplateUrl, subpath)}"   # ${t.templateName}`;
+            })
+                .join('\n');
+            throw new Error(`Found multiple Directus templates in ${ghTemplateUrl}. Re-run with one of:\n${list}`);
+        }
+        throw new Error(`No Directus template found at ${ghTemplateUrl}. A Directus template needs a package.json with a "templateName" field.`);
+    }
+    catch (error) {
+        throw new Error(`Failed to download GitHub template: ${getErrorMessage(error)}`, { cause: error });
+    }
+}
+export async function getInteractiveGithubTemplate(ghTemplateUrl) {
+    try {
+        const resolvedDir = await downloadGithubTemplate(ghTemplateUrl);
+        const template = await readTemplate(resolvedDir);
+        if (template) {
+            return [template];
+        }
+        const nested = await findNestedTemplates(resolvedDir, 3);
+        if (nested.length === 0) {
+            throw new Error(`No Directus template found at ${ghTemplateUrl}. A Directus template needs a package.json with a "templateName" field.`);
         }
-        return readTemplate(resolvedDir);
+        return nested;
     }
     catch (error) {
-        throw new Error(`Failed to download GitHub template: ${error}`);
+        throw new Error(`Failed to download GitHub template: ${getErrorMessage(error)}`, { cause: error });
     }
 }

package/dist/lib/utils/transform-github-url.d.ts

@@ -1 +1,8 @@
+export interface ParsedGitHubUrl {
+    owner: string;
+    ref?: string;
+    repo: string;
+    subpath?: string;
+}
+export declare function parseGitHubUrl(url: string): ParsedGitHubUrl;
 export declare function transformGitHubUrl(url: string): string;

package/dist/lib/utils/transform-github-url.js

@@ -1,11 +1,31 @@
+export function parseGitHubUrl(url) {
+    const cleaned = url.trim().replace(/\/+$/, '');
+    const urlToParse = /^https?:\/\//i.test(cleaned) ? cleaned : `https://${cleaned}`;
+    let parsed;
+    try {
+        parsed = new URL(urlToParse);
+    }
+    catch {
+        throw new Error(`Invalid GitHub URL: ${url}`);
+    }
+    if (!['github.com', 'www.github.com'].includes(parsed.hostname.toLowerCase())) {
+        throw new Error(`Invalid GitHub URL: ${url}`);
+    }
+    const pathParts = parsed.pathname.split('/').filter(Boolean);
+    const [owner, rawRepo, tree, ref, ...subpathParts] = pathParts;
+    const repo = rawRepo?.replace(/\.git$/, '');
+    if (!owner || !repo || pathParts.length > 2 && tree !== 'tree') {
+        throw new Error(`Invalid GitHub URL: ${url}`);
+    }
+    if (tree === 'tree' && !ref) {
+        throw new Error(`Invalid GitHub URL: ${url}`);
+    }
+    const subpath = subpathParts.length > 0 ? subpathParts.join('/') : undefined;
+    return { owner, ref, repo, subpath };
+}
 export function transformGitHubUrl(url) {
-    // Regular expression to capture the repository name and any subsequent path after the 'tree'
-    const regex = /github\.com\/([^/]+\/[^/]+)(?:\/tree\/[^/]+\/(.*))?$/;
-    const match = url.match(regex);
-    if (match) {
-        const repo = match[1];
-        const subpath = match[2] ? match[2] : '';
-        return `github:${repo}/${subpath}`;
-    }
-    return 'Invalid URL';
+    const { owner, ref, repo, subpath } = parseGitHubUrl(url);
+    const pathPart = subpath ? `/${subpath}` : '';
+    const refPart = ref ? `#${ref}` : '';
+    return `github:${owner}/${repo}${pathPart}${refPart}`;
 }

package/oclif.manifest.json

@@ -558,5 +558,5 @@
       ]
     }
   },
-  "version": "0.8.0-partials.0"
+  "version": "0.8.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directus-template-cli",
-  "version": "0.8.0-partials.0",
+  "version": "0.8.0",
   "description": "CLI Utility for applying templates to a Directus instance.",
   "author": "bryantgillespie @bryantgillespie",
   "type": "module",
@@ -19,44 +19,44 @@
   ],
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "@directus/sdk": "20.1.0",
-    "@inquirer/prompts": "^7.3.3",
-    "@oclif/core": "^4.2.9",
-    "@oclif/plugin-help": "^6.2.26",
-    "@oclif/plugin-plugins": "^5.4.34",
-    "@octokit/rest": "^21.1.1",
-    "@sindresorhus/slugify": "^2.2.1",
+    "@directus/sdk": "21.2.2",
+    "@inquirer/prompts": "^8.4.1",
+    "@oclif/core": "^4.10.5",
+    "@oclif/plugin-help": "^6.2.44",
+    "@oclif/plugin-plugins": "^5.4.61",
+    "@octokit/rest": "^22.0.1",
+    "@sindresorhus/slugify": "^3.0.0",
     "bottleneck": "^2.19.5",
-    "chalk": "5.4.1",
+    "chalk": "5.6.2",
     "cli-progress": "^3.12.0",
-    "defu": "^6.1.4",
-    "dotenv": "^16.4.7",
-    "execa": "9.5.2",
-    "giget": "^2.0.0",
-    "glob": "^11.0.1",
-    "log-update": "^6.1.0",
-    "nypm": "^0.6.0",
+    "defu": "^6.1.7",
+    "dotenv": "^17.4.2",
+    "execa": "9.6.1",
+    "giget": "^3.2.0",
+    "glob": "^13.0.6",
+    "log-update": "^8.0.0",
+    "nypm": "^0.6.5",
     "pathe": "^2.0.3",
-    "posthog-node": "^4.10.1"
+    "posthog-node": "^5.29.2"
   },
   "devDependencies": {
-    "@directus/types": "^13.0.0",
-    "@eslint/compat": "^1",
+    "@directus/types": "^15.0.2",
+    "@eslint/compat": "^2.0.5",
     "@oclif/prettier-config": "^0.2.1",
-    "@oclif/test": "^4",
-    "@types/chai": "^5.2.0",
+    "@oclif/test": "^4.1.18",
+    "@types/chai": "^5.2.3",
     "@types/mocha": "^10",
-    "@types/node": "^18",
-    "chai": "^5.2.0",
-    "eslint": "^9.39.2",
-    "eslint-config-oclif": "^6.0.130",
+    "@types/node": "^25.6.0",
+    "chai": "^6.2.2",
+    "eslint": "^10.2.1",
+    "eslint-config-oclif": "^6.0.157",
     "eslint-config-prettier": "^10",
-    "mocha": "^10",
-    "oclif": "^4",
-    "prettier": "^3.7.4",
-    "shx": "^0.3.3",
+    "mocha": "^11.7.5",
+    "oclif": "^4.23.0",
+    "prettier": "^3.8.3",
+    "shx": "^0.4.0",
     "ts-node": "^10",
-    "typescript": "^5.8.2"
+    "typescript": "^6.0.3"
   },
   "oclif": {
     "bin": "directus-template-cli",