@atlashub/smartstack-cli 3.20.0 → 3.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "3.20.0",
+  "version": "3.22.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",

package/templates/project/api.ts.template

@@ -1,31 +1,10 @@
-import axios from 'axios';
+// Re-export SmartStack's shared API client
+// IMPORTANT: Do NOT create a custom axios instance — use the SmartStack-provided client
+// which handles authentication, token refresh, and session management automatically.
+import { apiClient } from '@atlashub/smartstack';
 
-const api = axios.create({
-  baseURL: '/api',
-  headers: {
-    'Content-Type': 'application/json',
-  },
-});
+export default apiClient;
 
-// Request interceptor for auth token
-api.interceptors.request.use((config) => {
-  const token = localStorage.getItem('token');
-  if (token) {
-    config.headers.Authorization = `Bearer ${token}`;
-  }
-  return config;
-});
-
-// Response interceptor for error handling
-api.interceptors.response.use(
-  (response) => response,
-  (error) => {
-    if (error.response?.status === 401) {
-      localStorage.removeItem('token');
-      window.location.href = '/login';
-    }
-    return Promise.reject(error);
-  }
-);
-
-export default api;
+// For module-specific API calls, extend from the shared client:
+// import apiClient from './api';
+// export const getEmployees = () => apiClient.get('/api/business/humanresources/employees');

package/templates/project/appsettings.json.template

@@ -10,6 +10,7 @@
     "UseEntraId": false,
     "EnableSwagger": true,
     "CorsOrigins": [
+      "http://localhost:3000",
       "http://localhost:5173",
       "http://localhost:5174",
       "http://localhost:5175"

package/templates/skills/application/references/application-roles-template.md

@@ -50,7 +50,7 @@ public static class ApplicationRolesSeedData
 {
     // Deterministic GUIDs for application roles
     // Generated from: "role-{applicationId}-{roleType}"
-    private static readonly Guid ApplicationId = {ApplicationGuid}; // From NavigationApplicationSeedData
+    public static readonly Guid ApplicationId = NavigationApplicationSeedData.ApplicationId;
 
     public static readonly Guid AdminRoleId = GenerateRoleGuid("admin");
     public static readonly Guid ManagerRoleId = GenerateRoleGuid("manager");
@@ -141,7 +141,7 @@ public class ApplicationRoleSeedEntry
 |-------------|-------------|---------|
 | `{BaseNamespace}` | Root namespace of the client project | `SmartStack.Modules.RessourcesHumaines` |
 | `{AppLabel}` | Human-readable application label (EN) | `Human Resources` |
-| `{ApplicationGuid}` | GUID of the application (from NavigationApplicationSeedData) | `30f1fbba-e8c3-4879-9a49-d18deaa70a83` |
+| `ApplicationId` | Deterministic GUID from `NavigationApplicationSeedData.ApplicationId` — NO placeholder needed | Auto-resolved |
 
 ---
 

package/templates/skills/application/steps/step-05-frontend.md

@@ -102,7 +102,7 @@ This generates:
 
 > **CRITICAL:** This step is MANDATORY. Without it, routes exist as files but are invisible to the React Router. The page will be BLANK.
 
-After `scaffold_routes` generates the route files, you MUST manually insert the routes into `App.tsx`:
+After `scaffold_routes` generates the route files, you MUST manually insert the routes into `App.tsx`.
 
 **Step 4a:** Import the page components at the top of App.tsx:
 
@@ -112,33 +112,49 @@ import { {EntityName}Page } from '@/pages/{Context}/{Application}/{Module}/{Enti
 const {EntityName}Page = lazy(() => import('@/pages/{Context}/{Application}/{Module}/{EntityName}Page'));
 ```
 
-**Step 4b:** Find the correct Layout wrapper block in App.tsx:
+**Step 4b:** Detect the App.tsx routing pattern:
 
-| Context | Layout block to find |
-|---------|---------------------|
-| `platform.*` | `<Route path="/platform" element={<AdminLayout />}>` |
-| `business.*` | `<Route path="/business" element={<BusinessLayout />}>` |
-| `personal.*` | `<Route path="/personal/myspace" element={<UserLayout />}>` |
+Read App.tsx and detect which pattern is used:
 
-**Step 4c:** Insert route entries INSIDE the Layout block (as children, using relative paths):
+**Pattern A** — If App.tsx contains `contextRoutes: ContextRouteExtensions`:
+  → Add routes to `contextRoutes.{context}[]` with **RELATIVE** paths (no leading `/`)
 
-```tsx
-// ✅ CORRECT - Route added INSIDE the layout wrapper
-<Route path="/business" element={<BusinessLayout />}>
-  {/* ... existing routes ... */}
-  <Route path="{application}/{module}" element={<{EntityName}Page />} />
-</Route>
+  ```tsx
+  const contextRoutes: ContextRouteExtensions = {
+    business: [
+      // existing routes...
+      { path: '{application}/{module}/list', element: <{EntityName}ListPage /> },
+      { path: '{application}/{module}/new', element: <Create{EntityName}Page /> },
+      { path: '{application}/{module}/:id', element: <{EntityName}DetailPage /> },
+      { path: '{application}/{module}/:id/edit', element: <Create{EntityName}Page /> },
+    ],
+  };
+  ```
 
-// ❌ FORBIDDEN - Route added OUTSIDE layout (shell will NOT render!)
-<Route path="/business/{application}/{module}" element={<{EntityName}Page />} />
-```
+  Routes are automatically injected into BOTH standard (`/business/...`) and tenant-prefixed (`/t/:slug/business/...`) route trees by `mergeRoutes()`. No manual duplication needed.
+
+**Pattern B** — If App.tsx contains `<Route path="/{context}" element={<{Layout} />}>` (JSX Routes):
+  → Insert `<Route>` children inside the Layout wrapper (see below)
 
-**Step 4d:** ALSO add the same routes inside the tenant-prefixed block:
+  ```tsx
+  <Route path="/business" element={<BusinessLayout />}>
+    {/* ... existing routes ... */}
+    <Route path="{application}/{module}" element={<{EntityName}Page />} />
+  </Route>
+  ```
 
-Find `<Route path="/t/:slug">` and locate the matching `<Route path="{context}" element={<{Layout} />}>` inside it.
-Add the **same route entries** there.
+  ALSO add the same routes inside the tenant-prefixed block:
+  Find `<Route path="/t/:slug">` and add the **same route entries** there.
 
-**Step 4e:** Verify wiring:
+**Step 4c:** Context-to-Layout mapping:
+
+| Context | Layout Component | Route path |
+|---------|------------------|------------|
+| `platform.*` | `AdminLayout` | `/platform` |
+| `business.*` | `BusinessLayout` | `/business` |
+| `personal.*` | `UserLayout` | `/personal/myspace` |
+
+**Step 4d:** Verify wiring:
 
 ```
 Tool: mcp__smartstack__validate_frontend_routes
@@ -148,21 +164,10 @@ Args:
 
 If `appWiring.issues` is not empty, fix the wiring before proceeding.
 
-**For new applications (no existing layout route for the context):**
-
-If the context doesn't have a layout route yet, create one wrapping all child routes:
-
-```tsx
-<Route path="/{context}/{application}" element={<{Context}Layout />}>
-  <Route index element={<Navigate to="{default_module}" replace />} />
-  <Route path="{module}" element={<{EntityName}Page />} />
-</Route>
-```
-
-**FORBIDDEN:**
+**FORBIDDEN (both patterns):**
+- Adding business/platform/personal routes to `clientRoutes[]` with absolute paths — `clientRoutes` is ONLY for routes outside SmartStack contexts (e.g., `/about`, `/pricing`)
 - Adding routes OUTSIDE the Layout wrapper (shell will not render)
-- Adding routes only in the standard block but not in the tenant block
-- Using `createBrowserRouter` (SmartStack uses `BrowserRouter` with JSX `<Routes>`)
+- Using `createBrowserRouter` (SmartStack uses `useRoutes()` + `mergeRoutes()`)
 
 ### 5. Verify i18n Files
 

package/templates/skills/application/templates-frontend.md

@@ -488,7 +488,51 @@ export const $moduleApi = {
 
 ## TEMPLATE: ROUTES (App.tsx)
 
-### ⚠️ CRITICAL RULE 1: ROUTES MUST BE INSIDE LAYOUT WRAPPER
+### Detect App.tsx Routing Pattern FIRST
+
+Before adding routes, **read App.tsx** and detect which pattern is used:
+
+| Pattern | How to detect | Action |
+|---------|---------------|--------|
+| **Pattern A** (mergeRoutes) | `contextRoutes: ContextRouteExtensions` present | Add to `contextRoutes.{context}[]` array |
+| **Pattern B** (JSX Routes) | `<Route path="/{context}" element={<{Layout} />}>` present | Insert `<Route>` children inside Layout wrapper |
+
+### Pattern A: mergeRoutes (contextRoutes array)
+
+> **This is the DEFAULT pattern** generated by `smartstack init`.
+> Routes added to `contextRoutes` are automatically injected into BOTH standard and tenant-prefixed route trees by `mergeRoutes()`. No manual duplication needed.
+
+```tsx
+// Add to App.tsx — imports at top
+import { $MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALPage';
+import { $MODULE_PASCALDetailPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
+import { Create$MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
+
+// Add routes to contextRoutes.{context}[] with RELATIVE paths (no leading /)
+const contextRoutes: ContextRouteExtensions = {
+  $CONTEXT: [
+    // ... existing routes ...
+    { path: '$APPLICATION/$MODULE', element: <$MODULE_PASCALPage /> },
+    { path: '$APPLICATION/$MODULE/new', element: <Create$MODULE_PASCALPage /> },
+    { path: '$APPLICATION/$MODULE/:id', element: <$MODULE_PASCALDetailPage /> },
+    { path: '$APPLICATION/$MODULE/:id/edit', element: <Create$MODULE_PASCALPage /> },
+  ],
+};
+```
+
+**mergeRoutes auto-generates redirects** for intermediate paths (e.g., `$APPLICATION` → `$APPLICATION/$DEFAULT_MODULE`) so you don't need to add index redirects manually.
+
+**Context-to-Layout mapping (automatic via mergeRoutes):**
+
+| Context key | Injected into Layout | Standard path | Tenant path |
+|-------------|---------------------|---------------|-------------|
+| `platform` | `AdminLayout` | `/platform/...` | `/t/:slug/platform/...` |
+| `business` | `BusinessLayout` | `/business/...` | `/t/:slug/business/...` |
+| `personal` | `UserLayout` | `/personal/myspace/...` | `/t/:slug/personal/myspace/...` |
+
+### Pattern B: JSX Routes (inside Layout wrapper)
+
+> **Legacy pattern** — only used if App.tsx was manually restructured with JSX `<Route>` elements.
 
 SmartStack layouts (`AdminLayout`, `BusinessLayout`, `UserLayout`) provide the application shell: **header with AvatarMenu**, sidebar, navigation. They render child pages via React Router's `<Outlet />`.
 
@@ -504,13 +548,6 @@ SmartStack layouts (`AdminLayout`, `BusinessLayout`, `UserLayout`) provide the a
 3. Add the new routes **INSIDE** that `<Route>` block
 4. If a tenant-prefixed block exists (`/t/:slug/...`), add the routes there too
 
-**❌ FORBIDDEN - Flat routes OUTSIDE layout (AvatarMenu disappears!)**
-```tsx
-// These routes bypass the layout system entirely = NO header, NO sidebar, NO AvatarMenu
-<Route path="/$CONTEXT/$APPLICATION/$MODULE" element={<$MODULE_PASCALPage />} />
-```
-
-**✅ MANDATORY - Routes INSIDE the existing layout wrapper**
 ```tsx
 // Add to App.tsx
 
@@ -533,42 +570,33 @@ import { Create$MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/
 </Route>
 ```
 
-### Context-to-Layout mapping
+### ⚠️ CRITICAL RULES (both patterns)
 
-| Context | Layout Component | Layout Route Path |
-|---------|------------------|-------------------|
-| `platform` | `AdminLayout` | `/platform` |
-| `business` | `BusinessLayout` | `/business` |
-| `personal` | `UserLayout` | `/personal/myspace` |
-
-### ⚠️ CRITICAL RULE 2: NESTED ROUTES MANDATORY
-
-React Router v7 **requires** nested routes for multi-module applications.
-
-**❌ FORBIDDEN - Flat routes (cause redirects to Home)**
+**FORBIDDEN — Adding to clientRoutes[] with absolute paths:**
 ```tsx
-<Route path="$APPLICATION" element={<Navigate to="/$CONTEXT/$APPLICATION/$DEFAULT_MODULE" replace />} />
-<Route path="$APPLICATION/$MODULE" element={<$MODULE_PASCALPage />} />
+// ❌ WRONG — bypasses layout entirely, shell will NOT render
+const clientRoutes: RouteConfig[] = [
+  { path: '/business/$APPLICATION/$MODULE', element: <$MODULE_PASCALPage /> },
+];
 ```
 
-**✅ MANDATORY - Nested routes with index**
+`clientRoutes` is ONLY for routes **outside** SmartStack locked contexts (e.g., `/about`, `/pricing`).
+
+**FORBIDDEN — Flat routes outside layout:**
 ```tsx
-<Route path="$APPLICATION">
-  <Route index element={<Navigate to="$DEFAULT_MODULE" replace />} />
-  <Route path="$MODULE" element={<$MODULE_PASCALPage />} />
-</Route>
+// ❌ WRONG (Pattern B only) — flat route bypasses layout
+<Route path="/$CONTEXT/$APPLICATION/$MODULE" element={<$MODULE_PASCALPage />} />
 ```
 
-### Why this structure?
+### Why nested/context routes?
 
-| Aspect | Flat routes | Nested routes |
-|--------|------------|----------------|
-| Shell rendered | ❌ No (bypasses layout) | ✅ Yes (Outlet pattern) |
-| AvatarMenu visible | ❌ No | ✅ Yes |
-| Matching | Ambiguous between siblings | Hierarchical clear |
-| Navigate | Must be absolute | Can be relative |
-| Outlet | Not supported | Supported |
-| Redirect | Can fail | Always works |
+| Aspect | clientRoutes (wrong) | contextRoutes / nested (correct) |
+|--------|---------------------|----------------------------------|
+| Shell rendered | No (bypasses layout) | Yes (Outlet pattern) |
+| AvatarMenu visible | No | Yes |
+| Tenant prefix | Manual duplication | Automatic (mergeRoutes) |
+| Auto-redirects | None | Generated for intermediate paths |
+| Permission check | Bypassed (no RouteGuard) | Enforced by RouteGuard |
 
 ---