kalo-cli 0.1.0

package/generators/utils/code-manipulation.ts

@@ -0,0 +1,119 @@
+
+export const getMarkerStart = (className: string, context: string = 'AI_GENERATED_SNIPPET') => `# <!-- CLASS = ${className} START ${context} -->`;
+export const getMarkerEnd = (className: string, context: string = 'AI_GENERATED_SNIPPET') => `# <!-- CLASS = ${className} END ${context} -->`;
+
+/**
+ * Injects markers into the file content to guide AI code generation.
+ * Tries to place markers inside the specified class, preferably before 'class Meta' or at the top of the class.
+ */
+export const injectMarkers = (fileContent: string, className: string, context?: string): string => {
+    const markerStart = getMarkerStart(className, context);
+    const markerEnd = getMarkerEnd(className, context);
+
+    // Check if markers exist
+    if (fileContent.includes(markerStart) || fileContent.includes(markerEnd)) {
+        return fileContent;
+    }
+
+    console.log(`Markers for class ${className} not found, attempting to inject...`);
+
+    // Regex to find class definition
+    const classRegex = new RegExp(`^(\\s*)class\\s+${className}\\b.*?:`, 'm');
+    const classMatch = fileContent.match(classRegex);
+
+    if (classMatch) {
+        const classIndentation = classMatch[1];
+        const standardIndentation = '    '; // Assume 4 spaces
+        const injectionIndentation = classIndentation + standardIndentation;
+        
+        const classStartIndex = classMatch.index! + classMatch[0].length;
+        const contentAfterClassStart = fileContent.substring(classStartIndex);
+
+        // Search for 'class Meta' indented relative to our class
+        const metaRegex = new RegExp(`^${classIndentation}${standardIndentation}class Meta:`, 'm');
+        const metaMatch = contentAfterClassStart.match(metaRegex);
+        
+        if (metaMatch) {
+            // Inject before class Meta
+            const absoluteMetaIndex = classStartIndex + metaMatch.index!;
+            const beforeMeta = fileContent.substring(0, absoluteMetaIndex);
+            const afterMeta = fileContent.substring(absoluteMetaIndex);
+            
+            return `${beforeMeta}${injectionIndentation}${markerStart}\n${injectionIndentation}${markerEnd}\n\n${afterMeta}`;
+        } else {
+            // Inject at the top of the class body
+            const injection = `\n${injectionIndentation}${markerStart}\n${injectionIndentation}${markerEnd}\n`;
+            const beforeClassBody = fileContent.substring(0, classStartIndex);
+            const afterClassBody = fileContent.substring(classStartIndex);
+            
+            return beforeClassBody + injection + afterClassBody;
+        }
+    } else {
+        console.warn(`Class "${className}" not found in file. Appending markers to end of file.`);
+        return fileContent + `\n\n    ${markerStart}\n    ${markerEnd}\n`;
+    }
+};
+
+/**
+ * Applies the AI-generated JSON response to the content.
+ * Handles imports, replacements, and code injection between markers.
+ */
+export const applyGeneratedCode = (contentWithMarkers: string, generatedData: any, className: string, context?: string): string => {
+    const markerStart = getMarkerStart(className, context);
+    const markerEnd = getMarkerEnd(className, context);
+    
+    let newContent = contentWithMarkers;
+    const { imports = [], replacements = [], code = '' } = generatedData;
+
+    // 1. Handle Imports
+    if (imports.length > 0) {
+        const newImports = imports.filter((imp: string) => !newContent.includes(imp.trim()));
+        if (newImports.length > 0) {
+            // Add imports at the top, but try to be smart (after existing imports?)
+            // For simplicity, prepend.
+            newContent = newImports.join('\n') + '\n' + newContent;
+        }
+    }
+
+    // 2. Handle Replacements
+    if (replacements.length > 0) {
+        for (const rep of replacements) {
+            if (rep && rep.search && rep.replace) {
+                if (newContent.includes(rep.search)) {
+                    newContent = newContent.replace(rep.search, rep.replace);
+                } else {
+                    console.warn(`Replacement pattern not found: "${rep.search.substring(0, 40)}..."`);
+                }
+            }
+        }
+    }
+
+    // 3. Handle Code Injection
+    let newCode = code;
+    if (Array.isArray(newCode)) newCode = newCode.join('\n');
+    
+    if (typeof newCode === 'string' && newCode.trim().length > 0) {
+        const startIdx = newContent.indexOf(markerStart);
+        const endIdx = newContent.indexOf(markerEnd);
+        
+        if (startIdx !== -1 && endIdx !== -1) {
+            const prefix = newContent.substring(0, startIdx + markerStart.length);
+            const suffix = newContent.substring(endIdx);
+            
+            // Detect indentation from the line before start marker
+            const lastNewLine = newContent.lastIndexOf('\n', startIdx);
+            const indentation = (lastNewLine !== -1) 
+                ? newContent.substring(lastNewLine + 1, startIdx)
+                : '    ';
+
+            // Indent new code to match marker indentation
+            const indentedCode = newCode.split('\n')
+                .map(line => line.trim() ? indentation + line : line)
+                .join('\n');
+
+            return `${prefix}\n${indentedCode}\n${indentation}${suffix}`;
+        }
+    }
+    
+    return newContent;
+};

package/generators/utils/filesystem.ts

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Retrieves the list of existing Django applications in the project.
+ * Scans the 'app' directory in the current working directory.
+ *
+ * @returns {string[]} An array of application names (directory names).
+ * @throws {Error} If filesystem access fails (though basic read errors might propagate).
+ */
+export const getAppList = (): string[] => {
+  const appDir = path.join(process.cwd(), 'app');
+  if (!fs.existsSync(appDir)) {
+    return [];
+  }
+  return fs.readdirSync(appDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+};
+
+/**
+ * Recursively lists files in an application directory with filtering.
+ * Excludes test files, __init__.py, and specific directories.
+ * 
+ * @param {string} appName - The name of the application.
+ * @returns {string[]} List of relative file paths from the app root.
+ */
+export const getAppFiles = (appName: string): string[] => {
+    const appDir = path.join(process.cwd(), 'app', appName);
+    if (!fs.existsSync(appDir)) {
+        return [];
+    }
+
+    const files: string[] = [];
+    
+    const walk = (dir: string, relativePath: string) => {
+        const list = fs.readdirSync(dir, { withFileTypes: true });
+        
+        for (const dirent of list) {
+            const currentRelPath = path.join(relativePath, dirent.name);
+            const currentAbsPath = path.join(dir, dirent.name);
+
+            if (dirent.isDirectory()) {
+                // Exclude test directories and cache
+                if (!['__tests__', 'test', 'tests', '__pycache__', 'migrations'].includes(dirent.name)) {
+                    walk(currentAbsPath, currentRelPath);
+                }
+            } else {
+                // Exclude test files and __init__.py
+                if (
+                    dirent.name !== '__init__.py' &&
+                    !dirent.name.includes('.test.') &&
+                    !dirent.name.includes('.spec.') &&
+                    dirent.name.endsWith('.py') // Assume we only care about Python files for now based on context
+                ) {
+                    files.push(currentRelPath);
+                }
+            }
+        }
+    };
+
+    walk(appDir, '');
+    return files;
+};

package/generators/utils/index.ts

@@ -0,0 +1,47 @@
+/**
+ * Utility functions for file path resolution and naming conventions.
+ * Pure functions only.
+ */
+
+/**
+ * Formats a string into a URL-friendly slug.
+ * Converts to lowercase, replaces spaces with hyphens, and removes non-word characters.
+ *
+ * @param {string} text - The input string to format.
+ * @returns {string} The formatted slug string.
+ */
+export const formatSlug = (text: string): string => 
+  text.toLowerCase().replace(/ /g, '-').replace(/[^\w-]+/g, '');
+
+/**
+ * Formats a string into snake_case.
+ * Converts PascalCase or camelCase to snake_case.
+ *
+ * @param {string} text - The input string to format.
+ * @returns {string} The string in snake_case.
+ */
+export const formatSnakeCase = (text: string): string =>
+  text.replace(/\.?([A-Z])/g, (x, y) => "_" + y.toLowerCase()).replace(/^_/, "");
+
+/**
+ * Formats a string into PascalCase.
+ * Capitalizes the first letter of each word and removes non-alphanumeric characters.
+ *
+ * @param {string} text - The input string to format.
+ * @returns {string} The string in PascalCase.
+ */
+export const formatPascalCase = (text: string): string =>
+  text.replace(/(\w)(\w*)/g, (g0, g1, g2) => g1.toUpperCase() + g2.toLowerCase()).replace(/\W/g, "");
+
+/**
+ * Resolves the filesystem path for a given Django application.
+ * Assumes apps are located at the root or within an 'apps' structure.
+ *
+ * @param {string} appName - The name of the Django app.
+ * @returns {string} The resolved relative path to the app directory.
+ */
+export const resolveAppPath = (appName: string): string => {
+    // In a real scenario, this might check for an 'apps' directory existence
+    // For this generator, we default to root level apps for simplicity (KISS)
+    return `${appName}`;
+};

package/generators/utils/plop-actions.ts

@@ -0,0 +1,61 @@
+import { ActionType } from 'plop';
+
+/**
+ * Ensures a suffix is present on a name.
+ * 
+ * @param {string} name - The name to check.
+ * @param {string} suffix - The suffix to ensure.
+ * @returns {string} The name with the suffix.
+ */
+export const ensureSuffix = (name: string, suffix: string): string => {
+    if (name.endsWith(suffix)) return name;
+    return `${name}${suffix}`;
+};
+
+interface CreateAppendOptions {
+    path: string;
+    templateFile: string;
+    dumbData?: any;
+    appendData?: any;
+    dumbTemplateFile?: string;
+    dumbTemplate?: string;
+}
+
+/**
+ * Creates a pair of actions: one to ensure the file exists (using a "dumb" template rendering or specific init template),
+ * and one to append the actual content.
+ * 
+ * @param {CreateAppendOptions} options - Configuration options.
+ * @returns {ActionType[]} An array containing the add and append actions.
+ */
+export const createAppendActions = ({
+    path,
+    templateFile,
+    dumbData = { name: 'Dumb' },
+    appendData,
+    dumbTemplateFile,
+    dumbTemplate
+}: CreateAppendOptions): ActionType[] => {
+    const addAction: any = {
+        type: 'add',
+        path,
+        skipIfExists: true,
+        data: dumbData,
+    };
+    
+    if (dumbTemplate) {
+        addAction.template = dumbTemplate;
+    } else {
+        addAction.templateFile = dumbTemplateFile || templateFile;
+    }
+
+    return [
+        addAction,
+        {
+            type: 'append',
+            path,
+            templateFile,
+            data: appendData,
+        }
+    ];
+};

package/generators/utils/search.ts

@@ -0,0 +1,24 @@
+/**
+ * Utility for fuzzy searching/filtering choices in autocomplete prompts.
+ */
+
+/**
+ * Filters a list of choices based on the input string.
+ * Uses simple case-insensitive substring matching.
+ *
+ * @param {string | null} input - The search input from the user.
+ * @param {Array<{ name: string; value: any }>} choices - The list of choices to filter.
+ * @returns {Promise<Array<{ name: string; value: any }>>} The filtered list of choices.
+ */
+export const searchChoices = (input: string | null, choices: Array<{ name: string; value: any }>) => {
+    if (!input) {
+        return Promise.resolve(choices);
+    }
+
+    const lowerInput = input.toLowerCase();
+    const filtered = choices.filter((choice) =>
+        choice.name.toLowerCase().includes(lowerInput)
+    );
+
+    return Promise.resolve(filtered);
+};

package/generators/wagtail-admin/index.ts

@@ -0,0 +1,122 @@
+import { PlopGeneratorConfig } from 'plop';
+import { ensureSuffix } from '../utils/plop-actions';
+import { ADMIN_EXT_TYPES } from '../constants';
+import { searchChoices } from '../utils/search';
+
+/**
+ * Generator configuration for Wagtail Admin extensions.
+ * Allows creation of custom Admin Views or Template Components (Panels).
+ * Automatically registers hooks and creates template files.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const wagtailAdminGenerator: PlopGeneratorConfig = {
+  description: 'Créer une extension Wagtail Admin (Vue ou Composant)',
+  prompts: [
+    {
+      type: 'autocomplete',
+      name: 'type',
+      message: 'Quel type d\'extension voulez-vous créer ?',
+      source: (answers, input) => searchChoices(input, ADMIN_EXT_TYPES),
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Nom de l\'extension (ex: DashboardAdminView, WelcomePanel) :',
+      validate: (value, answers) => {
+          return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'app',
+      message: 'Nom de l\'application cible',
+    },
+  ],
+  actions: (data) => {
+    const actions = [];
+    const appPath = `app/${data.app}`;
+    const isView = data.type === 'view';
+
+    // Ensure suffixes
+    if (isView) {
+        if (!data.name.endsWith('AdminView')) {
+            data.name = `${data.name}AdminView`;
+        }
+    } else {
+        // Component or Panel
+        if (!data.name.endsWith('Component') && !data.name.endsWith('Panel')) {
+            data.name = `${data.name}Panel`;
+        }
+    }
+
+    if (isView) {
+        // --- Admin View ---
+        
+        // 1. Add View to views.py
+        actions.push({
+            type: 'append',
+            path: `${appPath}/views.py`,
+            templateFile: 'generators/wagtail-admin/templates/admin_view.py.hbs',
+        });
+
+        // 2. Add/Append wagtail_hooks.py
+        actions.push({
+            type: 'add',
+            path: `${appPath}/wagtail_hooks.py`,
+            templateFile: 'generators/wagtail-admin/templates/wagtail_hooks.py.hbs',
+            skipIfExists: true,
+        });
+        
+        // If file existed, we might need to append. 
+        // For simplicity, we just append the registration code. 
+        // Ideally we would check for imports, but appending is safer than overwriting.
+        // We use a different template for appending to avoid duplicate imports if possible, 
+        // but for now re-using the file with imports is "okay" in Python (just messy) 
+        // or we can rely on user to clean up.
+        // BETTER STRATEGY: Create a separate partial for appending without top-level imports if feasible.
+        // But for this MVP, let's just append the same content. 
+        // The user can deduplicate imports.
+        
+        actions.push({
+            type: 'append',
+            path: `${appPath}/wagtail_hooks.py`,
+            templateFile: 'generators/wagtail-admin/templates/wagtail_hooks.py.hbs',
+            unique: true, // Try to avoid exact duplicates
+        });
+
+        // 3. Create Template
+        actions.push({
+            type: 'add',
+            path: `${appPath}/templates/${data.app}/admin/{{snakeCase name}}.html`,
+            templateFile: 'generators/wagtail-admin/templates/admin_view.html.hbs',
+        });
+
+    } else {
+        // --- Template Component ---
+
+        // 1. Add Component to components.py
+        actions.push({
+            type: 'add',
+            path: `${appPath}/components.py`,
+            template: 'from wagtail.admin.ui.components import Component\n\n',
+            skipIfExists: true,
+        });
+
+        actions.push({
+            type: 'append',
+            path: `${appPath}/components.py`,
+            templateFile: 'generators/wagtail-admin/templates/component.py.hbs',
+        });
+
+        // 2. Create Template
+        actions.push({
+            type: 'add',
+            path: `${appPath}/templates/${data.app}/components/${data.name.toLowerCase().replace(/ /g, '_')}.html`,
+            templateFile: 'generators/wagtail-admin/templates/component.html.hbs',
+        });
+    }
+
+    return actions;
+  },
+};

package/generators/wagtail-admin/templates/admin_view.html.hbs

@@ -0,0 +1,21 @@
+
+{% extends "wagtailadmin/base.html" %}
+{% block titletag %}{{ title }}{% endblock %}
+
+{% block extra_css %}
+    {{ block.super }}
+    <style>
+        /* Add custom styles here */
+    </style>
+{% endblock %}
+
+{% block content %}
+    {% include "wagtailadmin/shared/header.html" with title=title icon="folder-open-inverse" %}
+
+    <div class="nice-padding">
+        <p>Content for {{ title }} goes here.</p>
+    </div>
+{% endblock %}
+
+<!-- CLASS = {{pascalCase name}} START AI_GENERATED_ADMIN_VIEW -->
+<!-- CLASS = {{pascalCase name}} END AI_GENERATED_ADMIN_VIEW -->

package/generators/wagtail-admin/templates/admin_view.py.hbs

@@ -0,0 +1,15 @@
+
+
+from django.shortcuts import render
+
+def {{snakeCase name}}(request):
+    """
+    Wagtail Admin View for {{name}}
+    """
+    # <!-- CLASS = {{pascalCase name}} START AI_GENERATED_ADMIN_VIEW -->
+    # <!-- CLASS = {{pascalCase name}} END AI_GENERATED_ADMIN_VIEW -->
+
+    context = {
+        'title': '{{titleCase name}}',
+    }
+    return render(request, '{{app}}/admin/{{snakeCase name}}.html', context)

package/generators/wagtail-admin/templates/component.html.hbs

@@ -0,0 +1,6 @@
+<!-- CLASS = {{pascalCase name}} START AI_GENERATED_COMPONENT -->
+<!-- CLASS = {{pascalCase name}} END AI_GENERATED_COMPONENT -->
+<div class="help-block help-info">
+    <h2>{{pascalCase name}} Component</h2>
+    <p>This is a custom Wagtail Admin Component.</p>
+</div>

package/generators/wagtail-admin/templates/component.py.hbs

@@ -0,0 +1,11 @@
+from wagtail.admin.ui.components import Component
+
+class {{pascalCase name}}(Component):
+    # <!-- CLASS = {{pascalCase name}} START AI_GENERATED_COMPONENT -->     
+    # <!-- CLASS = {{pascalCase name}} END AI_GENERATED_COMPONENT -->     
+    template_name = '{{app}}/components/{{snakeCase name}}.html'
+
+    def get_context_data(self, parent_context):
+        context = super().get_context_data(parent_context)
+        # context['username'] = parent_context['request'].user.username
+        return context

package/generators/wagtail-admin/templates/wagtail_hooks.py.hbs

@@ -0,0 +1,18 @@
+
+from django.urls import path, reverse
+from wagtail import hooks
+from .views import {{snakeCase name}}
+
+# <!-- CLASS = {{pascalCase name}}Hooks START AI_GENERATED_WAGTAIL_HOOKS -->
+# <!-- CLASS = {{pascalCase name}}Hooks END AI_GENERATED_WAGTAIL_HOOKS -->
+
+@hooks.register('register_admin_urls')
+def register_{{snakeCase name}}_url():
+    return [
+        path('{{snakeCase name}}/', {{snakeCase name}}, name='{{snakeCase name}}'),
+    ]
+
+@hooks.register('register_admin_menu_item')
+def register_{{snakeCase name}}_menu_item():
+    from wagtail.admin.menu import MenuItem
+    return MenuItem('{{titleCase name}}', reverse('{{snakeCase name}}'), icon_name='folder-open-inverse')

package/generators/wagtail-block/index.ts

@@ -0,0 +1,55 @@
+import { PlopGeneratorConfig } from 'plop';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ensureSuffix, createAppendActions } from '../utils/plop-actions';
+
+/**
+ * Generator configuration for Wagtail StreamField Blocks.
+ * Creates a new StructBlock and its corresponding template.
+ * Automatically suffixes block names with 'Block'.
+ *
+ * @type {PlopGeneratorConfig}
+ */
+export const wagtailBlockGenerator: PlopGeneratorConfig = {
+  description: 'Créer un nouveau Block Wagtail StreamField',
+  prompts: [
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Nom du Block (ex: Image, Quote) - Sera suffixé par "Block", pour construire du contenu flexible dans StreamField :',
+      validate: (value) => {
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'app',
+      message: 'Nom de l\'application cible',
+    },
+  ],
+  actions: (data) => {
+    const actions = [];
+    const appPath = data?.app || '';
+
+    // Ensure suffix
+    data.name = ensureSuffix(data.name, 'Block');
+
+    // This variable blocksFile is not really used by Plop actions directly but was here for calculation
+    // const blocksFile = path.join('app', appPath, 'blocks.py'); 
+
+    // 1. Ensure blocks.py exists and Append the block
+    actions.push(...createAppendActions({
+        path: `app/${data.app}/blocks.py`,
+        templateFile: 'generators/wagtail-block/templates/block_class.py.hbs'
+    }));
+
+    // 3. Create the template
+    actions.push({
+      type: 'add',
+      path: 'app/{{app}}/templates/{{app}}/blocks/{{snakeCase name}}.html',
+      templateFile: 'generators/wagtail-block/templates/block_template.html.hbs',
+    });
+
+    return actions;
+  },
+};

package/generators/wagtail-block/templates/block_class.py.hbs

@@ -0,0 +1,13 @@
+
+class {{pascalCase name}}(blocks.StructBlock):
+    """
+    {{pascalCase name}} block configuration.
+    """
+    title = blocks.CharBlock(required=True, help_text="Add your title")
+
+    # <!-- CLASS = {{pascalCase name}} START AI_GENERATED_BLOCK -->
+    # <!-- CLASS = {{pascalCase name}} END AI_GENERATED_BLOCK -->    
+    class Meta:
+        template = "{{app}}/blocks/{{snakeCase name}}.html"
+        icon = "placeholder"
+        label = "{{titleCase name}}"

package/generators/wagtail-block/templates/block_template.html.hbs

@@ -0,0 +1,5 @@
+<!-- CLASS = {{pascalCase name}} START AI_GENERATED_BLOCK -->
+<div class="block-{{dashCase name}}">
+    <h3>\{{ self.title }}</h3>
+</div>
+<!-- CLASS = {{pascalCase name}} END AI_GENERATED_BLOCK -->

package/generators/wagtail-page/actions/model.ts

@@ -0,0 +1,18 @@
+
+import { ActionType } from 'plop';
+import { createAppendActions } from '../../utils/plop-actions';
+
+/**
+ * Generates Plop actions for creating a standard Django model.
+ *
+ * @param {any} data - The prompt answers data containing 'name' and 'app'.
+ * @returns {ActionType[]} An array of Plop actions to create/update model files.
+ */
+export const getModelActions = (data: any): ActionType[] => {
+  const appPath = `app/${data.app}`;
+
+  return createAppendActions({
+      path: `${appPath}/models/models.py`,
+      templateFile: 'generators/wagtail-page/templates/django_model.py.hbs'
+  });
+};

package/generators/wagtail-page/actions/orderable.ts

@@ -0,0 +1,21 @@
+
+import { ActionType } from 'plop';
+import { ensureSuffix, createAppendActions } from '../../utils/plop-actions';
+
+/**
+ * Generates Plop actions for creating a Wagtail Orderable model.
+ * Automatically ensures the name ends with 'Orderable'.
+ *
+ * @param {any} data - The prompt answers data.
+ * @returns {ActionType[]} An array of Plop actions to create/update orderable files.
+ */
+export const getOrderableActions = (data: any): ActionType[] => {
+  const appPath = `app/${data.app}`;
+
+  data.name = ensureSuffix(data.name, 'Orderable');
+  
+  return createAppendActions({
+      path: `${appPath}/models/orderables.py`,
+      templateFile: 'generators/wagtail-page/templates/orderable_model.py.hbs'
+  });
+};

package/generators/wagtail-page/actions/page.ts

@@ -0,0 +1,40 @@
+
+import { ActionType } from 'plop';
+import { createAppendActions } from '../../utils/plop-actions';
+
+/**
+ * Generates Plop actions for creating a pair of Wagtail Pages (Index + Detail).
+ * Calculates a 'baseName' by removing 'Page' suffix if present.
+ *
+ * @param {any} data - The prompt answers data.
+ * @returns {ActionType[]} An array of Plop actions to create models, templates, and tests.
+ */
+export const getPageActions = (data: any): ActionType[] => {
+  const actions: ActionType[] = [];
+  const appPath = `app/${data.app}`;
+  
+  // Clean base name: Remove 'Page' if present to avoid BlogPagePage
+  const baseName = data.name.replace(/Page$/, '');
+  data.baseName = baseName; // Store for templates
+
+  // Ensure models/pages.py exists and append models
+  actions.push(...createAppendActions({
+      path: `${appPath}/models/pages.py`,
+      templateFile: 'generators/wagtail-page/templates/page_pair_model.py.hbs',
+      dumbData: { baseName: 'Dumb' }
+  }));
+
+  // Create HTML templates for both
+  actions.push({
+    type: 'add',
+    path: `${appPath}/templates/${data.app}/{{snakeCase baseName}}_index_page.html`,
+    templateFile: 'generators/wagtail-page/templates/page_template.html.hbs',
+  });
+  actions.push({
+    type: 'add',
+    path: `${appPath}/templates/${data.app}/{{snakeCase baseName}}_page.html`,
+    templateFile: 'generators/wagtail-page/templates/page_template.html.hbs',
+  });
+  
+  return actions;
+};