@lenne.tech/cli 1.19.0 → 1.20.0

package/build/lib/workspace-integration.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Helpers for integrating an API (`projects/api/`) or an App
+ * (`projects/app/`) into a fullstack workspace. Used by `lt fullstack
+ * init` (full-workspace flow) and by `lt fullstack add-api` /
+ * `lt fullstack add-app` (incremental flow on an already-existing
+ * workspace that only ships one half of the stack).
+ *
+ * The functions here own the small amount of "monorepo glue" that sits
+ * between the framework-agnostic setup primitives in
+ * `extensions/server.ts` and `extensions/frontend-helper.ts`:
+ *
+ *   - writing `projects/api/lt.config.json` with the resolved api/
+ *     framework mode so that follow-up generators (lt server module
+ *     etc.) pick it up without re-probing,
+ *   - patching the frontend `.env` with the project-specific storage
+ *     prefix,
+ *   - running the experimental `bun run rename` step for the
+ *     `--next` nest-base template,
+ *   - running the post-install format pass on the touched sub-project,
+ *
+ * They deliberately do NOT manage workspace-level concerns
+ * (lt-monorepo clone, root CLAUDE.md patching, top-level pnpm install,
+ * git initialisation). Those stay in `commands/fullstack/init.ts`
+ * because they only happen once per workspace creation. add-api /
+ * add-app run on an already-installed workspace and only need to wire
+ * in the new sub-project plus run a workspace-wide install.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSubProjectContext = detectSubProjectContext;
+exports.detectWorkspaceLayout = detectWorkspaceLayout;
+exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.isNonInteractive = isNonInteractive;
+exports.runExperimentalNestBaseRename = runExperimentalNestBaseRename;
+exports.runStandaloneWorkspaceGate = runStandaloneWorkspaceGate;
+exports.shouldProceedAsStandalone = shouldProceedAsStandalone;
+exports.writeApiConfig = writeApiConfig;
+/**
+ * Detect whether the current working directory IS a sub-project of an
+ * lt-monorepo workspace (i.e. cwd is `projects/api/` or `projects/app/`,
+ * or any nested directory thereof). Returns the workspace root + the
+ * sub-project kind so the caller can give a precise hint like
+ * "you're inside projects/api — go up to the workspace root".
+ *
+ * Returns `null` when cwd is not inside such a sub-project.
+ */
+function detectSubProjectContext(startDir, filesystem) {
+    const root = findWorkspaceRoot(startDir, filesystem);
+    if (!root)
+        return null;
+    // If the start dir IS the root, we're not inside a sub-project.
+    if (root === startDir)
+        return null;
+    const apiDir = filesystem.path(root, 'projects', 'api');
+    const appDir = filesystem.path(root, 'projects', 'app');
+    // Resolve absolute prefixes for a clean startsWith compare. We use
+    // the gluegun-resolved paths because all callers go through it.
+    const startAbs = filesystem.path(startDir);
+    if (startAbs === apiDir || startAbs.startsWith(`${apiDir}/`)) {
+        return { kind: 'api', subProjectDir: apiDir, workspaceRoot: root };
+    }
+    if (startAbs === appDir || startAbs.startsWith(`${appDir}/`)) {
+        return { kind: 'app', subProjectDir: appDir, workspaceRoot: root };
+    }
+    return null;
+}
+/**
+ * Detect what's already present in a workspace directory. Used by the
+ * fullstack commands to decide whether to perform a full init, only
+ * add the missing sub-project, or refuse because both halves already
+ * exist.
+ */
+function detectWorkspaceLayout(workspaceDir, filesystem) {
+    const projectsDir = `${workspaceDir}/projects`;
+    const apiDir = `${projectsDir}/api`;
+    const appDir = `${projectsDir}/app`;
+    // `hasWorkspaceMarker` covers pnpm-workspace.yaml, npm/yarn
+    // `workspaces` in package.json, and the `projects/` directory
+    // convention. Mirrors what `findWorkspaceRoot` walks for.
+    const hasWorkspace = hasWorkspaceMarker(workspaceDir, filesystem);
+    // For "hasApi"/"hasApp", a directory existing is not enough — empty
+    // or stub directories from a partially-cloned monorepo would yield
+    // false positives. Require at least a package.json inside.
+    const hasApi = filesystem.exists(`${apiDir}/package.json`) === 'file';
+    const hasApp = filesystem.exists(`${appDir}/package.json`) === 'file';
+    return { hasApi, hasApp, hasWorkspace, workspaceDir };
+}
+/**
+ * Walk up from `startDir` until a workspace marker is found or the
+ * filesystem root is reached. Limited to 6 levels to avoid pathological
+ * scans on deeply-nested CWDs (e.g. inside a temp dir hierarchy).
+ *
+ * Returns the directory that contains the marker, or `null` if none
+ * was found within the search budget. Used by the standalone commands
+ * to detect the case "user is inside `projects/api/` and ran
+ * `lt frontend nuxt` there".
+ */
+function findWorkspaceRoot(startDir, filesystem, maxDepth = 6) {
+    // Resolve to an absolute path so the parent traversal is reliable.
+    // gluegun's filesystem.path is a join helper; we want the OS path.
+    let cur = startDir;
+    // First check the start dir itself.
+    if (hasWorkspaceMarker(cur, filesystem))
+        return cur;
+    for (let i = 0; i < maxDepth; i++) {
+        const parent = filesystem.path(cur, '..');
+        if (parent === cur)
+            return null;
+        if (hasWorkspaceMarker(parent, filesystem))
+            return parent;
+        cur = parent;
+    }
+    return null;
+}
+/**
+ * Treat the caller as "non-interactive" (KI/CI) when either
+ *   - `--noConfirm` was passed explicitly, OR
+ *   - stdin is not a TTY (typical for `claude < script.txt`, piped CI
+ *     runs, or any agent that captures the CLI's stdout).
+ *
+ * The TTY check catches AI agents that call `lt …` without
+ * `--noConfirm` (Claude Code does this) and would otherwise hit the
+ * `confirm()` prompt forever. Caller can opt out via `force`.
+ *
+ * Exposed so commands can derive their `noConfirm` value once and
+ * pass the same boolean to `shouldProceedAsStandalone`.
+ */
+function isNonInteractive(noConfirmFlag) {
+    if (noConfirmFlag)
+        return true;
+    // process.stdin may be undefined in some test runners — guard.
+    return Boolean(process.stdin && process.stdin.isTTY === false);
+}
+/**
+ * Run the experimental `bun run rename <projectDir>` step. Only relevant
+ * for the `--next` nest-base template (it ships hard-coded `nest-base`
+ * references in package.json, README.md, portless.yml, and
+ * docker-compose.yml). Failures are non-fatal — the workspace is still
+ * usable, and the user can re-run the rename script manually.
+ *
+ * Returns true if the step was attempted (regardless of success). The
+ * caller decides whether to surface a warning.
+ */
+function runExperimentalNestBaseRename(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiDir, patching, projectDir, system } = options;
+        // setupServerForFullstack already patched package.json to set
+        // `name = projectDir`. The rename planner reads that name as the
+        // "old" slug, which would short-circuit the rest of the rewrites
+        // because they still say `nest-base`. Restore the canonical
+        // `name = "nest-base"` first so the planner has a coherent starting
+        // state across all four files.
+        yield patching.update(`${apiDir}/package.json`, (config) => {
+            config.name = 'nest-base';
+            return config;
+        });
+        try {
+            yield system.run(`cd ${apiDir} && bun run rename ${projectDir}`);
+            return { attempted: true };
+        }
+        catch (err) {
+            return { attempted: true, error: err };
+        }
+    });
+}
+/**
+ * Print + prompt + decision for a standalone scaffolding command's
+ * workspace gate. Centralises the ~25 lines of identical logic that
+ * `lt server create`, `lt frontend nuxt`, and `lt frontend angular`
+ * each had inline.
+ *
+ * Side effects (intentionally bundled — easier to reason about as one
+ * unit, and the three commands all want the same shape):
+ *   - prints the workspace-detected note + sub-project hint
+ *   - asks the user via `confirm()` when interactive
+ *   - prints the refusal/abort reason via `print.error` when refused
+ *   - calls `process.exit(1)` on refusal (unless `fromGluegunMenu`)
+ *
+ * Returns `true` when the caller may proceed, `false` when the caller
+ * has already been told to abort and should `return` from its `run`.
+ *
+ * The shape stays narrow on purpose — adding more knobs (e.g.
+ * "abort message format") would just push the duplication elsewhere.
+ */
+function runStandaloneWorkspaceGate(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { cwd, filesystem, force, fromGluegunMenu, noConfirmFlag, pieceName, print: { confirm, error, info }, projectKind, suggestion, } = options;
+        // Sub-project hint: if the user is inside `projects/api/` or
+        // `projects/app/` of a workspace, point them at the root explicitly
+        // — the standalone path would otherwise clone a sibling tree
+        // *inside* the existing sub-project, which is almost never wanted.
+        const subProject = detectSubProjectContext(cwd, filesystem);
+        if (subProject) {
+            info('');
+            info(`You appear to be inside projects/${subProject.kind}/ of a workspace at ${subProject.workspaceRoot}.`);
+            info(`  → Run \`${suggestion}\` from the workspace root instead.`);
+            error(`Refusing to create a standalone ${projectKind} from inside a sub-project. cd to the workspace root first.`);
+            if (!fromGluegunMenu)
+                process.exit(1);
+            return false;
+        }
+        const layout = detectWorkspaceLayout(cwd, filesystem);
+        if (!layout.hasWorkspace) {
+            return true; // Plain dir → standalone is fine, no gate.
+        }
+        const alreadyHas = pieceName === 'api' ? layout.hasApi : layout.hasApp;
+        info('');
+        info('Note: current directory looks like a fullstack workspace (pnpm-workspace.yaml, package.json#workspaces, or projects/).');
+        if (!alreadyHas) {
+            info(`  → To integrate the ${pieceName} into this workspace, use \`${suggestion}\`.`);
+        }
+        else {
+            info(`  → projects/${pieceName}/ already exists in this workspace; this command would create a separate ${projectKind}.`);
+        }
+        const nonInteractive = isNonInteractive(noConfirmFlag);
+        const userConfirmed = nonInteractive
+            ? undefined
+            : yield confirm(`Proceed with standalone ${projectKind} creation anyway?`, false);
+        const decision = shouldProceedAsStandalone({
+            force,
+            nonInteractive,
+            projectKind,
+            suggestion,
+            userConfirmed,
+        });
+        if (!decision.proceed) {
+            error((_a = decision.reason) !== null && _a !== void 0 ? _a : 'Aborted.');
+            if (!fromGluegunMenu)
+                process.exit(1);
+            return false;
+        }
+        if (nonInteractive && force) {
+            info('  --force set — continuing despite workspace context.');
+        }
+        info('');
+        return true;
+    });
+}
+/**
+ * Decide whether a standalone scaffolding command (`lt server create`,
+ * `lt frontend nuxt`, `lt frontend angular`) should run inside a
+ * directory that already looks like a fullstack workspace.
+ *
+ * Three modes:
+ *
+ *   - **interactive** (the user can answer a prompt) — caller asks via
+ *     `confirm()` and passes the result as `userConfirmed`.
+ *   - **non-interactive without force** — refuse. This is the path AI
+ *     agents and CI scripts take by default (either `--noConfirm` was
+ *     set, or stdin isn't a TTY). Forcing them onto the workspace-
+ *     aware command (`add-api` / `add-app`) prevents stray side-by-
+ *     side clones that pnpm-workspace.yaml does not pick up.
+ *   - **non-interactive with --force** — proceed, but the caller
+ *     should log a hint so the override is visible in CI logs.
+ *
+ * The function does NOT print or prompt. It only decides; the caller
+ * owns the interaction surface.
+ */
+function shouldProceedAsStandalone(options) {
+    const { force, nonInteractive, projectKind, suggestion, userConfirmed } = options;
+    // Interactive caller already gave an explicit yes/no.
+    if (userConfirmed !== undefined) {
+        return userConfirmed
+            ? { proceed: true }
+            : { proceed: false, reason: `Aborted standalone ${projectKind} creation. Use \`${suggestion}\` instead.` };
+    }
+    // Non-interactive path: refuse unless --force is set. This is the
+    // AI-agent / CI default — fail loud rather than silently produce a
+    // stray clone that does not integrate with the workspace.
+    if (nonInteractive && !force) {
+        return {
+            proceed: false,
+            reason: `Refusing to create a standalone ${projectKind} inside an existing fullstack workspace ` +
+                `(non-interactive caller detected). ` +
+                `Use \`${suggestion}\` for the workspace-aware flow, or pass --force to override (rare).`,
+        };
+    }
+    // Non-interactive + force: caller knows what they want.
+    return { proceed: true };
+}
+/**
+ * Write `projects/api/lt.config.json` with the apiMode and frameworkMode
+ * baked in so follow-up generators (lt server module, addProp,
+ * permissions) can pick the correct controller type and detect vendor
+ * mode without re-probing the file tree.
+ *
+ * Idempotent: overwrites whatever was at `lt.config.json` so a re-run
+ * after an apiMode change reflects the new value.
+ */
+function writeApiConfig(options) {
+    const { apiDir, apiMode, filesystem, frameworkMode } = options;
+    filesystem.write(filesystem.path(apiDir, 'lt.config.json'), {
+        commands: {
+            server: {
+                module: {
+                    controller: apiMode,
+                },
+            },
+        },
+        meta: {
+            apiMode,
+            frameworkMode,
+            version: '1.0.0',
+        },
+    }, { jsonIndent: 2 });
+}
+/**
+ * Probe a single directory for workspace markers. Pure helper used by
+ * `detectWorkspaceLayout` and `findWorkspaceRoot`.
+ *
+ * Recognised markers (any one is sufficient):
+ *   - `pnpm-workspace.yaml`           — pnpm workspace
+ *   - `package.json` with `workspaces` field — npm/yarn/bun workspaces
+ *   - `projects/` directory           — lt-monorepo convention
+ *
+ * Returns false for `node_modules`-style directories that may contain
+ * a stray `package.json` with `workspaces`.
+ */
+function hasWorkspaceMarker(dir, filesystem) {
+    var _a;
+    if (filesystem.exists(`${dir}/pnpm-workspace.yaml`) === 'file')
+        return true;
+    if (filesystem.exists(`${dir}/projects`) === 'dir')
+        return true;
+    const pkgPath = `${dir}/package.json`;
+    if (filesystem.exists(pkgPath) !== 'file')
+        return false;
+    const pkg = filesystem.read(pkgPath, 'json');
+    if (!pkg)
+        return false;
+    // npm/yarn workspaces: `workspaces` is either an array of globs
+    // (`["packages/*"]`) or an object with a `packages` array
+    // (yarn classic). Both count.
+    const ws = pkg.workspaces;
+    if (Array.isArray(ws) && ws.length > 0)
+        return true;
+    if (ws && typeof ws === 'object' && Array.isArray(ws.packages)) {
+        return ((_a = ws.packages) !== null && _a !== void 0 ? _a : []).length > 0;
+    }
+    return false;
+}

package/docs/commands.md

@@ -67,7 +67,7 @@ lt cli rename <new-name>
 
 ### `lt server create`
 
-Creates a new NestJS server project.
+Creates a new standalone NestJS server project in a sibling directory. For an in-workspace API, prefer [`lt fullstack add-api`](#lt-fullstack-add-api).
 
 **Usage:**
 ```bash
@@ -77,17 +77,27 @@ lt server create [name] [options]
 **Options:**
 | Option | Description |
 |--------|-------------|
+| `--name <name>` | Server name (preferred over the positional argument) |
 | `--description <text>` | Project description |
 | `--author <name>` | Author name |
 | `--api-mode <Rest\|GraphQL\|Both>` | API mode (ignored with `--next`) |
 | `--framework-mode <npm\|vendor>` | Framework consumption mode (ignored with `--next`) |
+| `--framework-upstream-branch <ref>` | Upstream `nest-server` branch/tag/commit to vendor (only with `--framework-mode vendor`) |
 | `--branch <branch>` / `-b` | Branch of nest-server-starter to use as template |
 | `--copy <path>` / `-c` | Copy from local template directory instead of cloning |
 | `--link <path>` | Symlink to local template directory (fastest, changes affect original) |
 | `--git` | Initialize git repository |
 | `--next` | **Experimental:** clone [`nest-base`](https://github.com/lenneTech/nest-base) (Bun + Prisma 7 + Postgres + Better-Auth) instead of `nest-server-starter`. Skips API-mode / vendor-mode / install / lt.config.json processing. |
+| `--dry-run` | Print the resolved plan and exit without making any changes |
+| `--force` | Override the workspace-detection abort under `--noConfirm` |
 | `--noConfirm` | Skip confirmation prompts |
 
+**Workspace-awareness:** When run inside a directory that already looks like a fullstack workspace (contains `pnpm-workspace.yaml` or `projects/`), the command behaves differently per mode:
+
+- **interactive** → asks for confirmation before creating a stray standalone clone
+- **`--noConfirm` without `--force`** → **refuses** with exit code 1 and points the caller to `lt fullstack add-api`. This is the default behaviour for AI agents and CI scripts: fail loud rather than produce a stray clone that pnpm-workspace.yaml does not pick up.
+- **`--noConfirm --force`** → proceeds and logs a hint so the override is visible in CI logs.
+
 **CLAUDE.md Patching:** If the project contains a `CLAUDE.md`, the generic API mode description is replaced with the selected mode. In single-mode projects (`Rest` or `GraphQL`), the "API Mode System" documentation section is condensed to a brief note. Skipped when `--next` is used.
 
 **Configuration:** `commands.server.create.*`, `defaults.author`, `defaults.noConfirm`
@@ -558,6 +568,82 @@ Additionally, the API's `CLAUDE.md` is patched to reflect the selected API mode
 
 **Configuration:** `commands.fullstack.*`, `defaults.noConfirm`
 
+**Auto-detection in existing workspaces:** When `lt fullstack init` runs without a name argument inside a directory that already looks like a fullstack workspace (contains `pnpm-workspace.yaml` or `projects/`), it inspects the layout and dispatches to the matching incremental command:
+
+- both `projects/api` and `projects/app` exist → refuses with a hint to use `add-api` / `add-app` directly
+- only `projects/app` exists → delegates to `lt fullstack add-api` (with all original flags forwarded)
+- only `projects/api` exists → delegates to `lt fullstack add-app`
+- neither exists → falls through to the regular new-workspace flow
+
+To force a brand-new workspace from inside an existing one, pass `--name <slug>`.
+
+---
+
+### `lt fullstack add-api`
+
+Add a NestJS API (`projects/api/`) to an existing fullstack workspace that currently only contains a frontend (`projects/app/`). Mirrors every API-related flag from `lt fullstack init` so configuration stays consistent across both flows.
+
+**Usage:**
+```bash
+lt fullstack add-api [options]
+```
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `--api-mode <mode>` | API mode: `Rest`, `GraphQL`, or `Both` |
+| `--framework-mode <mode>` | Backend framework consumption mode: `npm` (classic) or `vendor` (core copied to `src/core/`) |
+| `--framework-upstream-branch <ref>` | Upstream `nest-server` branch/tag/commit to vendor (only with `--framework-mode vendor`) |
+| `--api-branch <branch>` | Branch of `nest-server-starter` to clone |
+| `--api-copy <path>` | Copy API from a local template directory |
+| `--api-link <path>` | Symlink API to a local template directory (fastest, changes affect original) |
+| `--next` | **Experimental:** clone [`nest-base`](https://github.com/lenneTech/nest-base) (Bun + Prisma 7 + Postgres + Better-Auth) instead of `nest-server-starter`. Forces `--api-mode Rest` and `--framework-mode npm`, runs `bun run rename` post-clone, skips workspace install. |
+| `--workspace-dir <path>` | Workspace root. When omitted, defaults to cwd; if cwd is not a workspace, the command walks up until it finds one (so it works from inside `projects/api/src/`). |
+| `--skip-install` | Skip `pnpm install` and the post-install format pass |
+| `--dry-run` | Print the resolved plan without making any changes |
+| `--noConfirm` | Skip all interactive prompts |
+
+**Refusal cases:**
+- `projects/api/` already exists → suggests `lt fullstack init` in a fresh directory
+- no workspace detected at the target path → asks the user to run `lt fullstack init` first
+
+**Side effects:** writes `projects/api/lt.config.json` with the resolved `apiMode` + `frameworkMode`, hoists workspace-scoped `pnpm.overrides` from sub-projects to the root, runs `pnpm install` + `oxfmt` on the new sub-project (unless `--skip-install` is set).
+
+**Configuration:** Reads `commands.fullstack.*` (same keys as `lt fullstack init`).
+
+---
+
+### `lt fullstack add-app`
+
+Add a frontend app (`projects/app/`) to an existing fullstack workspace that currently only contains an API (`projects/api/`). Mirrors every frontend-related flag from `lt fullstack init`.
+
+**Usage:**
+```bash
+lt fullstack add-app [options]
+```
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `--frontend <type>` | Frontend framework: `nuxt` or `angular` |
+| `--frontend-framework-mode <mode>` | Frontend framework consumption mode: `npm` or `vendor` (nuxt-extensions copied to `app/core/`) |
+| `--frontend-branch <branch>` | Branch of the frontend starter to clone (`ng-base-starter` or `nuxt-base-starter`) |
+| `--frontend-copy <path>` | Copy frontend from a local template directory |
+| `--frontend-link <path>` | Symlink frontend to a local template directory (fastest, changes affect original) |
+| `--next` | Default the nuxt-base-starter ref to the `next` branch (auth `basePath` aligned with the experimental `--next` API) |
+| `--workspace-dir <path>` | Workspace root. When omitted, defaults to cwd; if cwd is not a workspace, the command walks up until it finds one (so it works from inside `projects/api/src/`). |
+| `--skip-install` | Skip `pnpm install` and the post-install format pass |
+| `--dry-run` | Print the resolved plan without making any changes |
+| `--noConfirm` | Skip all interactive prompts |
+
+**Refusal cases:**
+- `projects/app/` already exists → suggests `lt fullstack init` in a fresh directory
+- no workspace detected at the target path → asks the user to run `lt fullstack init` first
+
+**Side effects:** patches `projects/app/.env` with a project-specific `NUXT_PUBLIC_STORAGE_PREFIX`, optionally vendorizes `nuxt-extensions` into `app/core/`, hoists workspace-scoped `pnpm.overrides`, runs `pnpm install` + `oxfmt` on the new sub-project (unless `--skip-install` is set).
+
+**Configuration:** Reads `commands.fullstack.*` (same keys as `lt fullstack init`).
+
 ---
 
 ### `lt fullstack convert-mode`
@@ -689,7 +775,7 @@ lt npm update
 
 ### `lt frontend angular`
 
-Creates a new Angular workspace using ng-base-starter.
+Creates a new standalone Angular workspace using ng-base-starter. For an in-workspace app, prefer [`lt fullstack add-app --frontend angular`](#lt-fullstack-add-app).
 
 **Usage:**
 ```bash
@@ -699,21 +785,26 @@ lt frontend angular [name] [options]
 **Options:**
 | Option | Description |
 |--------|-------------|
+| `--name <name>` | Workspace name (preferred over the positional argument) |
 | `--branch <branch>` / `-b` | Branch of ng-base-starter to use as template |
 | `--copy <path>` / `-c` | Copy from local template directory instead of cloning |
 | `--link <path>` | Symlink to local template directory (fastest, changes affect original) |
 | `--localize` | Enable Angular localize |
 | `--noLocalize` | Disable Angular localize |
 | `--gitLink <url>` | Git repository URL to link |
+| `--dry-run` | Print the resolved plan and exit without making any changes |
+| `--force` | Override the workspace-detection abort under `--noConfirm` |
 | `--noConfirm` / `-y` | Skip confirmation prompts |
 
+**Workspace-awareness:** Inside a fullstack workspace the command is interactive (confirm prompt), but under `--noConfirm` it **refuses** with exit code 1 and points the caller to `lt fullstack add-app --frontend angular`. Pass `--noConfirm --force` to override (rare).
+
 **Configuration:** `commands.frontend.angular.*`, `defaults.noConfirm`
 
 ---
 
 ### `lt frontend nuxt`
 
-Creates a new Nuxt workspace using nuxt-base-starter.
+Creates a new standalone Nuxt workspace using nuxt-base-starter. For an in-workspace app, prefer [`lt fullstack add-app --frontend nuxt`](#lt-fullstack-add-app).
 
 **Usage:**
 ```bash
@@ -723,16 +814,24 @@ lt frontend nuxt [options]
 **Options:**
 | Option | Description |
 |--------|-------------|
+| `--name <name>` | Workspace name |
 | `--branch <branch>` / `-b` | Branch of nuxt-base-starter to use (uses git clone instead of create-nuxt-base) |
 | `--copy <path>` / `-c` | Copy from local template directory instead of cloning |
 | `--link <path>` | Symlink to local template directory (fastest, changes affect original) |
+| `--frontend-framework-mode <npm\|vendor>` | Frontend framework consumption mode (`vendor` copies `nuxt-extensions` into `app/core/`) |
+| `--next` | Default branch to `nuxt-base-starter#next` (auth `basePath` aligned with the experimental `--next` API) |
+| `--dry-run` | Print the resolved plan and exit without making any changes |
+| `--force` | Override the workspace-detection abort under `--noConfirm` |
+| `--noConfirm` | Skip confirmation prompts (requires `--name`) |
 
 **Note:** For `--copy` and `--link`, specify the path to the `nuxt-base-template/` subdirectory, not the repository root:
 ```bash
 lt frontend nuxt --copy /path/to/nuxt-base-starter/nuxt-base-template
 ```
 
-**Configuration:** `commands.frontend.nuxt.*`
+**Workspace-awareness:** Inside a fullstack workspace the command is interactive (confirm prompt), but under `--noConfirm` it **refuses** with exit code 1 and points the caller to `lt fullstack add-app --frontend nuxt`. Pass `--noConfirm --force` to override (rare).
+
+**Configuration:** `commands.frontend.nuxt.*`, `commands.fullstack.frontendFrameworkMode` (shared with `init` / `add-app`)
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",
@@ -31,6 +31,7 @@
     "coverage": "jest --coverage",
     "test:vendor-init": "bash scripts/test-vendor-init.sh",
     "test:frontend-vendor-init": "bash scripts/test-frontend-vendor-init.sh",
+    "test:incremental-fullstack": "bash scripts/test-incremental-fullstack.sh",
     "format": "prettier --write 'src/**/*.{js,ts,tsx,json}' '!src/templates/**/*'",
     "lint": "eslint './src/**/*.{ts,js,vue}'",
     "lint:fix": "eslint './src/**/*.{ts,js,vue}' --fix",