@azure-net/cli 2.3.6 → 2.3.62

package/bin/azure-net.js

@@ -21,7 +21,12 @@ import {
     generatePresenter,
     generateModule,
     generateCrudBase,
-    generateCrudPresenter
+    generateCrudPresenter,
+    generateModuleBase,
+    generateModulePresenter,
+    generateComponent,
+    generateWidget,
+    generateDesignComponent
 } from '../src/commands/generate/index.js';
 
 const program = new Command();
@@ -130,4 +135,29 @@ program
     .description('Generate CRUD presenter for existing service')
     .action(generateCrudPresenter);
 
+program
+    .command('make:module-base')
+    .description('Generate repository and service for a module')
+    .action(generateModuleBase);
+
+program
+    .command('make:module-presenter')
+    .description('Generate presenter for existing service')
+    .action(generateModulePresenter);
+
+program
+    .command('make:component')
+    .description('Generate UI component')
+    .action(generateComponent);
+
+program
+    .command('make:widget')
+    .description('Generate UI widget')
+    .action(generateWidget);
+
+program
+    .command('make:design-component')
+    .description('Generate design system component')
+    .action(generateDesignComponent);
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "2.3.6",
+  "version": "2.3.62",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"

package/src/commands/generate/generateComponent.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const componentTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{componentName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateComponent() {
+    const context = await selectContext('Select context for component:');
+
+    const { componentPath } = await prompts({
+        type: 'text',
+        name: 'componentPath',
+        message: 'Component path (e.g. reviews/modals/ReviewModal):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = componentPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const componentName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/components/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/components');
+    const fullComponentPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating component: ${componentName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'Component.svelte'),
+        componentTemplate.replace(/{{componentName}}/g, componentName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Component created at: ${fullComponentPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/generateCrudBase.js

@@ -116,7 +116,7 @@ export default async function generateCrudBase() {
     // Get available datasources
     const contextPath = getContextPath(context);
     const coreDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/datasources')
+        path.join(process.cwd(), 'src/core/datasources')
     );
     const contextDatasources = await getAvailableFiles(
         path.join(contextPath, 'infrastructure/http/datasources')

package/src/commands/generate/generateCrudPresenter.js

@@ -114,7 +114,7 @@ export default async function generateCrudPresenter() {
 
     // Get schema factory
     const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/schemas')
+        path.join(process.cwd(), 'src/core/schemas')
     );
 
     const { schemaType } = await prompts({
@@ -129,7 +129,7 @@ export default async function generateCrudPresenter() {
 
     // Get presenter factory
     const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/presenters')
+        path.join(process.cwd(), 'src/core/presenters')
     );
 
     const { presenterType } = await prompts({

package/src/commands/generate/generateDatasource.js

@@ -23,12 +23,12 @@ export default async function generateDatasource() {
 
     const pascalName = toPascalCase(name);
     const contextPath = context === 'core'
-        ? path.join(process.cwd(), 'src/app/core')
+        ? path.join(process.cwd(), 'src/core')
         : getContextPath(context);
 
     // Get available responses
     const coreResponses = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/responses')
+        path.join(process.cwd(), 'src/core/responses')
     );
 
     const contextResponses = context !== 'core'

package/src/commands/generate/generateDesignComponent.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const designComponentTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{componentName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateDesignComponent() {
+    const context = await selectContext('Select context for design component:');
+
+    const { componentPath } = await prompts({
+        type: 'text',
+        name: 'componentPath',
+        message: 'Design component path (e.g. Button/Themes/PrimaryButton):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = componentPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const componentName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/design/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/design');
+    const fullComponentPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating design component: ${componentName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'Component.svelte'),
+        designComponentTemplate.replace(/{{componentName}}/g, componentName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Design component created at: ${fullComponentPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/generateModuleBase.js

@@ -0,0 +1,152 @@
+import prompts from 'prompts';
+import path from 'path';
+import {
+    selectContext,
+    getContextPath,
+    toPascalCase,
+    toCamelCase,
+    getAvailableFiles,
+    toKebabCase
+} from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
+
+const entityTemplate = `export interface I{{name}} {
+\tid: number;
+\t// Add entity fields here
+\tcreated_at: string;
+\tupdated_at: string;
+}`;
+
+const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
+
+export class {{name}}Repository {
+\tprivate endpoint = '{{endpoint}}';
+\t
+\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
+\t
+\tpublic async example() {
+\t\treturn this.{{datasourceVar}}.createRequest(({ http }) =>
+\t\t\thttp.get(this.endpoint)
+\t\t).then(res => res.getData());
+\t}
+}`;
+
+const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
+import { {{name}}Repository } from '\${{context}}/infrastructure/http/repositories';
+
+export class {{name}}Service extends ClassMirror<{{name}}Repository> {
+\tconstructor(private {{camelName}}Repository: {{name}}Repository) {
+\t\tsuper({{camelName}}Repository);
+\t}
+\t
+\tdeclare example: {{name}}Repository['example'];
+}`;
+
+export default async function generateModuleBase() {
+    const context = await selectContext('Select context for module base:');
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Module name (PascalCase):'
+    });
+
+    const { endpoint } = await prompts({
+        type: 'text',
+        name: 'endpoint',
+        message: 'API endpoint (e.g. /api/users):'
+    });
+
+    const { needEntity } = await prompts({
+        type: 'confirm',
+        name: 'needEntity',
+        message: 'Create domain entity?',
+        initial: true
+    });
+
+    // Get available datasources
+    const contextPath = getContextPath(context);
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/core/datasources')
+    );
+    const contextDatasources = await getAvailableFiles(
+        path.join(contextPath, 'infrastructure/http/datasources')
+    );
+
+    const allDatasources = [
+        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
+        ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
+    ];
+
+    const { datasource } = await prompts({
+        type: 'select',
+        name: 'datasource',
+        message: 'Select datasource:',
+        choices: allDatasources
+    });
+
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const entityLower = toKebabCase(pascalName);
+
+    console.log('\n🚀 Generating module base (repository & service)...\n');
+
+    // 1. Create Domain entity if needed
+    if (needEntity) {
+        const domainPath = path.join(contextPath, 'domain', entityLower);
+        const modelPath = path.join(domainPath, 'model');
+
+        await writeIfNotExists(
+            path.join(modelPath, `I${pascalName}.ts`),
+            entityTemplate.replace(/{{name}}/g, pascalName)
+        );
+
+        await writeIfNotExists(
+            path.join(modelPath, 'index.ts'),
+            `export * from './I${pascalName}';`
+        );
+
+        await writeIfNotExists(
+            path.join(domainPath, 'index.ts'),
+            `export * from './model';`
+        );
+
+        console.log(`✅ Domain entity I${pascalName} created`);
+    }
+
+    // 2. Create Repository
+    const repoPath = path.join(contextPath, 'infrastructure/http/repositories');
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/datasources'
+        : `\$${context}/infrastructure/http/datasources`;
+
+    await writeIfNotExists(
+        path.join(repoPath, `${pascalName}Repository.ts`),
+        repositoryTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{endpoint}}/g, endpoint)
+            .replace(/{{datasource}}/g, datasource.name)
+            .replace(/{{datasourceImport}}/g, datasourceImport)
+            .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name))
+    );
+    await updateIndexTs(repoPath);
+
+    // 3. Create Service
+    const servicePath = path.join(contextPath, 'application/services');
+    await writeIfNotExists(
+        path.join(servicePath, `${pascalName}Service.ts`),
+        serviceTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{camelName}}/g, camelName)
+            .replace(/{{context}}/g, context)
+    );
+    await updateIndexTs(servicePath);
+
+    // Update core index
+    await updateCoreIndex();
+
+    console.log(`\n✅ Module base for ${pascalName} created successfully!`);
+    console.log(`\n💡 Remember to:`);
+    console.log(`   1. Add ${pascalName}Repository to InfrastructureProvider`);
+    console.log(`   2. Add ${pascalName}Service to ApplicationProvider`);
+}

package/src/commands/generate/generateModulePresenter.js

@@ -0,0 +1,110 @@
+import prompts from 'prompts';
+import path from 'path';
+import {
+    selectContext,
+    getContextPath,
+    toPascalCase,
+    getAvailableFiles,
+    getApplicationProviderServices,
+    toKebabCase
+} from '../../utils/contextUtils.js';
+import { updateIndexTs, writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
+
+const presenterWithCoreTemplate = `import { {{presenterFactory}} } from '$core/presenters';
+import { ApplicationProvider } from '\${{context}}/application';
+
+export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+\t// Add your presenter methods here
+\t
+\treturn {};
+});`;
+
+const presenterWithoutCoreTemplate = `import { createPresenter } from '@azure-net/kit';
+import { ApplicationProvider } from '\${{context}}/application';
+
+export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+\t// Add your presenter methods here
+\t
+\treturn {};
+});`;
+
+export default async function generateModulePresenter() {
+    const context = await selectContext('Select context for module presenter:');
+
+    // Get available services from ApplicationProvider
+    const services = await getApplicationProviderServices(context);
+
+    if (services.length === 0) {
+        console.error('❌ No services found in ApplicationProvider. Add services manually first.');
+        return;
+    }
+
+    const { service } = await prompts({
+        type: 'select',
+        name: 'service',
+        message: 'Select service for presenter:',
+        choices: services.map(s => ({ title: s, value: s }))
+    });
+
+    const { moduleName } = await prompts({
+        type: 'text',
+        name: 'moduleName',
+        message: 'Module name for presenter (will create folder in delivery):'
+    });
+
+    // Extract entity name from service name
+    const pascalName = toPascalCase(moduleName);
+    const entityLower = toKebabCase(pascalName);
+
+    // Get presenter factory
+    const corePresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/core/presenters')
+    );
+
+    const { presenterType } = await prompts({
+        type: 'select',
+        name: 'presenterType',
+        message: 'Select presenter factory:',
+        choices: [
+            { title: 'Use createPresenter from package', value: 'package' },
+            ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
+        ]
+    });
+
+    const contextPath = getContextPath(context);
+    const deliveryModulePath = path.join(contextPath, 'delivery', entityLower);
+
+    console.log('\n🚀 Generating module presenter...\n');
+
+    // Create Presenter
+    const presenterTemplate = presenterType === 'package'
+        ? presenterWithoutCoreTemplate
+        : presenterWithCoreTemplate;
+
+    const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
+
+    await writeIfNotExists(
+        path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
+        presenterTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{serviceName}}/g, service)
+            .replace(/{{presenterFactory}}/g, presenterFactory)
+    );
+
+    // Create module index
+    await writeIfNotExists(
+        path.join(deliveryModulePath, 'index.ts'),
+        `export * from './${pascalName}Presenter';`
+    );
+
+    // Update core index
+    await updateCoreIndex();
+
+    console.log(`✅ Module presenter for ${pascalName} created successfully!`);
+    console.log(`\n💡 Remember to add presenter methods using the ${service}.`);
+}

package/src/commands/generate/generatePresenter.js

@@ -42,7 +42,7 @@ export default async function generatePresenter() {
 
     // Check for core presenters
     const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/presenters')
+        path.join(process.cwd(), 'src/core/presenters')
     );
 
     const presenterChoices = [

package/src/commands/generate/generateRepository.js

@@ -27,7 +27,7 @@ export default async function generateRepository() {
     // Get available datasources
     const contextPath = getContextPath(context);
     const coreDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/datasources')
+        path.join(process.cwd(), 'src/core/datasources')
     );
     const contextDatasources = await getAvailableFiles(
         path.join(contextPath, 'infrastructure/http/datasources')

package/src/commands/generate/generateResponse.js

@@ -19,7 +19,7 @@ export default async function generateResponse() {
 
     const pascalName = toPascalCase(name);
     const contextPath = context === 'core'
-        ? path.join(process.cwd(), 'src/app/core')
+        ? path.join(process.cwd(), 'src/core')
         : getContextPath(context);
 
     const responsePath = context === 'core'

package/src/commands/generate/generateSchema.js

@@ -45,7 +45,7 @@ export default async function generateSchema() {
 
     // Check for core schemas
     const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/schemas')
+        path.join(process.cwd(), 'src/core/schemas')
     );
 
     const choices = [

package/src/commands/generate/generateWidget.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const widgetTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{widgetName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateWidget() {
+    const context = await selectContext('Select context for widget:');
+
+    const { widgetPath } = await prompts({
+        type: 'text',
+        name: 'widgetPath',
+        message: 'Widget path (e.g. modals/ConfirmModal):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = widgetPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const widgetName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/widgets/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/widgets');
+    const fullWidgetPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating widget: ${widgetName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullWidgetPath, 'Component.svelte'),
+        widgetTemplate.replace(/{{widgetName}}/g, widgetName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullWidgetPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Widget created at: ${fullWidgetPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/index.js

@@ -6,4 +6,9 @@ export { default as generateSchema } from './generateSchema.js';
 export { default as generatePresenter } from './generatePresenter.js';
 export { default as generateModule } from './generateModule.js';
 export { default as generateCrudBase } from './generateCrudBase.js';
-export { default as generateCrudPresenter } from './generateCrudPresenter.js';
+export { default as generateCrudPresenter } from './generateCrudPresenter.js';
+export { default as generateModuleBase } from './generateModuleBase.js';
+export { default as generateModulePresenter } from './generateModulePresenter.js';
+export { default as generateComponent } from './generateComponent.js';
+export { default as generateWidget } from './generateWidget.js';
+export { default as generateDesignComponent } from './generateDesignComponent.js';

package/src/commands/init/initAliases.js

@@ -10,11 +10,10 @@ function generateAliases(config) {
 
     return Object.fromEntries([
         ...contexts.flatMap(c => [
-            [`$${c}`, `./src/app/contexts/${c}/layers`],
-            [`$${c}/ui`, `./src/app/contexts/${c}/ui`]
+            [`$${c}`, `./src/app/${c}/layers`],
+            [`$${c}/ui`, `./src/app/${c}/ui`]
         ]),
-        ['$shared', './src/app/shared'],
-        ['$core', './src/app/core']
+        ['$core', './src/core']
     ]);
 }
 

package/src/commands/init/initMiddleware.js

@@ -1,7 +1,7 @@
 import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const middlewarePath = path.join(process.cwd(), 'src/app/core/middleware/MiddlewareManager.ts');
+const middlewarePath = path.join(process.cwd(), 'src/core/middleware/MiddlewareManager.ts');
 
 const middlewareTemplate = `import { createMiddlewareManager } from '@azure-net/kit';
 
@@ -10,7 +10,7 @@ export const { clientMiddleware, serverMiddleware } = createMiddlewareManager([]
 export default async function initMiddleware() {
     await writeIfNotExists(middlewarePath, middlewareTemplate);
     await writeIfNotExists(
-        path.join(process.cwd(), 'src/app/core/middleware/index.ts'),
+        path.join(process.cwd(), 'src/core/middleware/index.ts'),
         `export * from './MiddlewareManager';`
     );
 

package/src/commands/init/initPresenter.js

@@ -1,7 +1,7 @@
 import {updateCoreIndex, writeIfNotExists} from '../../utils/fileUtils.js';
 import path from 'path';
 
-const presenterPath = path.join(process.cwd(), 'src/app/core/presenters/AppPresenter.ts');
+const presenterPath = path.join(process.cwd(), 'src/core/presenters/AppPresenter.ts');
 
 const presenterTemplate = `import { createPresenterFactory } from '@azure-net/kit/edges';
 import { createAsyncHelpers, createErrorParser } from '@azure-net/kit';
@@ -14,7 +14,7 @@ export const AppPresenter = createPresenterFactory({ ...AsyncHelpers, handleErro
 export default async function initPresenter() {
     await writeIfNotExists(presenterPath, presenterTemplate);
     await writeIfNotExists(
-        path.join(process.cwd(), 'src/app/core/presenters/index.ts'),
+        path.join(process.cwd(), 'src/core/presenters/index.ts'),
         `export * from './AppPresenter';`
     );
 

package/src/commands/init/initSchema.js

@@ -1,7 +1,7 @@
 import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const schemaPath = path.join(process.cwd(), 'src/app/core/schemas/Schema.ts');
+const schemaPath = path.join(process.cwd(), 'src/core/schemas/Schema.ts');
 
 const schemaTemplate = `import { createSchemaFactory } from '@azure-net/kit';
 import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
@@ -11,7 +11,7 @@ export const Schema = createSchemaFactory(createRules(validationMessagesI18n));`
 export default async function initSchema() {
     await writeIfNotExists(schemaPath, schemaTemplate);
     await writeIfNotExists(
-        path.join(process.cwd(), 'src/app/core/schemas/index.ts'),
+        path.join(process.cwd(), 'src/core/schemas/index.ts'),
         `export * from './Schema';`
     );
 

package/src/commands/init/initStructure.js

@@ -3,10 +3,8 @@ import path from 'path';
 import { loadUserConfig } from '../../utils/loadConfig.js';
 import { updateCoreIndex } from '../../utils/fileUtils.js';
 
-const APP_ROOT = path.join(process.cwd(), 'src', 'app');
-const CONTEXTS_PATH = path.join(APP_ROOT, 'contexts');
-const SHARED_PATH = path.join(APP_ROOT, 'shared');
-const CORE_PATH = path.join(APP_ROOT, 'core');
+const APP_PATH = path.join(process.cwd(), 'src', 'app');
+const CORE_PATH = path.join(process.cwd(), 'src', 'core');
 
 async function createDirIfNotExists(dirPath) {
     try {
@@ -118,17 +116,14 @@ export default async function initStructure() {
 
     console.log('📦 Generating architecture...');
 
-    // Create contexts
+    // Create contexts directly in src/app
     for (const context of contexts) {
-        const contextPath = path.join(CONTEXTS_PATH, context);
+        const contextPath = path.join(APP_PATH, context);
         const contextName = context.charAt(0).toUpperCase() + context.slice(1);
         await createBaseStructure(contextPath, contextName, context);
     }
 
-    // Create empty shared folder
-    await createDirIfNotExists(SHARED_PATH);
-
-    // Create core structure with all functionality
+    // Create core structure with all functionality (in src/core, not src/app/core)
     await createDirIfNotExists(CORE_PATH);
     await createDirIfNotExists(path.join(CORE_PATH, 'datasources'));
     await createDirIfNotExists(path.join(CORE_PATH, 'responses'));
@@ -136,6 +131,7 @@ export default async function initStructure() {
     await createDirIfNotExists(path.join(CORE_PATH, 'middleware'));
     await createDirIfNotExists(path.join(CORE_PATH, 'presenters'));
     await createDirIfNotExists(path.join(CORE_PATH, 'translations'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'providers'));
 
     // Update core index
     await updateCoreIndex();

package/src/commands/init/initTranslations.js

@@ -1,7 +1,7 @@
 import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const translationsPath = path.join(process.cwd(), 'src/app/core/translations');
+const translationsPath = path.join(process.cwd(), 'src/core/translations');
 
 const translationProviderTemplate = `import { messages } from './locales';
 import { createTranslations } from '@azure-net/kit/i18n';

package/src/commands/init/migrateStructure.js

@@ -2,7 +2,10 @@ import fs from 'fs/promises';
 import path from 'path';
 import { loadUserConfig } from '../../utils/loadConfig.js';
 
-const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
+const APP_PATH = path.join(process.cwd(), 'src/app');
+const OLD_CONTEXTS_PATH = path.join(APP_PATH, 'contexts');
+const OLD_CORE_PATH = path.join(APP_PATH, 'core');
+const NEW_CORE_PATH = path.join(process.cwd(), 'src/core');
 
 async function directoryExists(dirPath) {
     try {
@@ -33,36 +36,87 @@ async function moveDirectory(source, destination) {
     }
 }
 
+async function removeEmptyDir(dirPath) {
+    try {
+        await fs.rmdir(dirPath);
+        console.log(`🗑️  Removed empty directory: ${dirPath}`);
+    } catch {
+        // Directory not empty or doesn't exist
+    }
+}
+
 export default async function migrateStructure() {
     const config = await loadUserConfig();
     const contexts = config.contexts || ['app'];
 
     console.log('🔄 Starting structure migration...\n');
-    console.log('This will reorganize existing contexts to use layers and ui folders.\n');
+    console.log('This will reorganize existing structure to the new format:\n');
+    console.log('  - src/app/contexts/{context} -> src/app/{context}');
+    console.log('  - src/app/core -> src/core');
+    console.log('  - Ensure layers and ui folders exist\n');
+
+    // Step 1: Migrate core from src/app/core to src/core
+    if (await directoryExists(OLD_CORE_PATH)) {
+        console.log('📦 Migrating core...');
+
+        // Check if new core already exists
+        if (await directoryExists(NEW_CORE_PATH)) {
+            console.log('⚠️  Core already exists at src/core, skipping core migration...');
+        } else {
+            await moveDirectory(OLD_CORE_PATH, NEW_CORE_PATH);
+        }
+    }
 
+    // Step 2: Migrate contexts
     for (const context of contexts) {
-        const contextPath = path.join(CONTEXTS_PATH, context);
+        console.log(`\n📁 Migrating context: ${context}`);
+
+        const oldContextPath = path.join(OLD_CONTEXTS_PATH, context);
+        const newContextPath = path.join(APP_PATH, context);
+
+        // Check if context exists in old location (src/app/contexts/{context})
+        if (await directoryExists(oldContextPath)) {
+            // Check if new location already exists
+            if (await directoryExists(newContextPath)) {
+                console.log(`⚠️  Context '${context}' already exists at src/app/${context}, skipping...`);
+                continue;
+            }
+
+            // Move from contexts/{context} to app/{context}
+            await moveDirectory(oldContextPath, newContextPath);
+        }
+
+        // Now ensure the context has layers and ui structure
+        const contextPath = newContextPath;
 
-        // Check if context exists
         if (!(await directoryExists(contextPath))) {
             console.log(`⚠️  Context '${context}' does not exist, skipping...`);
             continue;
         }
 
-        console.log(`\n📁 Migrating context: ${context}`);
-
-        // Check if already migrated (has layers folder)
         const layersPath = path.join(contextPath, 'layers');
+        const uiPath = path.join(contextPath, 'ui');
+
+        // Check if already has layers structure
         if (await directoryExists(layersPath)) {
-            console.log(`⚠️  Context '${context}' already migrated, skipping...`);
+            console.log(`✓ Context '${context}' already has layers structure`);
+
+            // Just ensure ui folder exists
+            if (!(await directoryExists(uiPath))) {
+                await fs.mkdir(uiPath, { recursive: true });
+                console.log(`✅ Created: ${uiPath}`);
+            }
+
             continue;
         }
 
-        // Create layers and ui folders
+        // Need to create layers structure
+        console.log(`📦 Creating layers structure for '${context}'...`);
+
         await fs.mkdir(layersPath, { recursive: true });
-        await fs.mkdir(path.join(contextPath, 'ui'), { recursive: true });
+        await fs.mkdir(uiPath, { recursive: true });
         console.log(`✅ Created: ${layersPath}`);
-        console.log(`✅ Created: ${path.join(contextPath, 'ui')}`);
+        console.log(`✅ Created: ${uiPath}`);
 
         // Move existing layer folders to layers directory
         const layerFolders = ['domain', 'infrastructure', 'application', 'delivery'];
@@ -77,8 +131,14 @@ export default async function migrateStructure() {
         console.log(`✅ Context '${context}' migration completed!`);
     }
 
+    // Step 3: Clean up old contexts folder if empty
+    if (await directoryExists(OLD_CONTEXTS_PATH)) {
+        await removeEmptyDir(OLD_CONTEXTS_PATH);
+    }
+
     console.log('\n✅ Structure migration complete!');
     console.log('\n💡 Next steps:');
     console.log('   1. Run "azure-net init:aliases" to update path aliases');
     console.log('   2. Verify all imports are working correctly');
+    console.log('   3. Update any hardcoded paths in your code');
 }

package/src/utils/contextUtils.js

@@ -3,8 +3,8 @@ import path from 'path';
 import prompts from 'prompts';
 import { loadUserConfig } from './loadConfig.js';
 
-const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
-const CORE_PATH = path.join(process.cwd(), 'src/app/core');
+const APP_PATH = path.join(process.cwd(), 'src/app');
+const CORE_PATH = path.join(process.cwd(), 'src/core');
 
 export async function selectContext(message = 'Select context:') {
     const config = await loadUserConfig();
@@ -26,7 +26,7 @@ export async function selectContext(message = 'Select context:') {
 export function getContextPath(context) {
     return context === 'core'
         ? CORE_PATH
-        : path.join(CONTEXTS_PATH, context, 'layers');
+        : path.join(APP_PATH, context, 'layers');
 }
 
 export async function getAvailableFiles(dir, pattern = '.ts') {

package/src/utils/fileUtils.js

@@ -29,7 +29,7 @@ export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.t
 }
 
 export async function updateCoreIndex() {
-    const corePath = path.join(process.cwd(), 'src/app/core');
+    const corePath = path.join(process.cwd(), 'src/core');
     try {
         const dirs = await fs.readdir(corePath, { withFileTypes: true });
         const validDirs = [];