@emeryld/manager 0.5.1 → 0.6.1

package/dist/create-package/variants/client.js

@@ -1,122 +1 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
-const CLIENT_SCRIPTS = [
-    'dev',
-    'build',
-    'typecheck',
-    'lint',
-    'lint:fix',
-    'format',
-    'format:check',
-    'clean',
-    'test',
-];
-export function clientIndexTs(contractImport) {
-    const contractImportLine = contractImport
-        ? `import { registry } from '${contractImport}'`
-        : "// TODO: import { registry } from '@your-scope/contract'";
-    const routeExports = contractImport
-        ? `export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
-export const healthPost = routeClient.build(registry.byKey['POST /api/health'])`
-        : `// TODO: add route builders after wiring your contract registry
-// export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
-// export const healthPost = routeClient.build(registry.byKey['POST /api/health'])`;
-    return `import { QueryClient } from '@tanstack/react-query'
-import { createRouteClient } from '@emeryld/rrroutes-client'
-${contractImportLine}
-
-const baseUrl = process.env.RRR_API_URL ?? 'http://localhost:4000'
-export const queryClient = new QueryClient()
-
-export const routeClient = createRouteClient({
-  baseUrl,
-  queryClient,
-  environment: process.env.NODE_ENV === 'production' ? 'production' : 'development',
-})
-
-${routeExports}
-`;
-}
-export function clientPackageJson(name, contractName, options) {
-    const dependencies = {
-        '@emeryld/rrroutes-client': '^2.5.3',
-        '@tanstack/react-query': '^5.90.12',
-        'socket.io-client': '^4.8.3',
-    };
-    if (contractName)
-        dependencies[contractName] = 'workspace:*';
-    return basePackageJson({
-        name,
-        scripts: baseScripts('tsx watch src/index.ts', undefined, {
-            includePrepare: options?.includePrepare,
-        }),
-        dependencies,
-        devDependencies: {
-            ...BASE_LINT_DEV_DEPENDENCIES,
-            '@types/node': '^24.10.2',
-        },
-    });
-}
-async function clientFiles(pkgName, contractImport, targetDir) {
-    const includePrepare = isWorkspaceRoot(targetDir);
-    const tsconfig = await packageTsConfig(targetDir, {
-        include: ['src/**/*.ts', 'src/**/*.tsx'],
-        lib: ['ES2020', 'DOM'],
-        types: ['react', 'react-native'],
-        jsx: 'react-jsx',
-    });
-    return {
-        'package.json': clientPackageJson(pkgName, contractImport, { includePrepare }),
-        'tsconfig.json': tsconfig,
-        ...basePackageFiles(),
-        'src/index.ts': clientIndexTs(contractImport),
-        'README.md': buildReadme({
-            name: pkgName,
-            description: 'Starter RRRoutes client scaffold.',
-            scripts: CLIENT_SCRIPTS,
-            sections: [
-                {
-                    title: 'Getting Started',
-                    lines: [
-                        '- Install deps: `npm install` (or `pnpm install`)',
-                        '- Start dev mode: `npm run dev`',
-                        '- Build output: `npm run build`',
-                    ],
-                },
-                {
-                    title: 'Usage',
-                    lines: [
-                        contractImport
-                            ? `- Contract wired to ${contractImport}; adjust the import in \`src/index.ts\` if needed.`
-                            : '- Add your contract import to `src/index.ts` and wire the registry when ready.',
-                        '- Use the exported `queryClient` and built route clients from `src/index.ts`.',
-                    ],
-                },
-                {
-                    title: 'Environment',
-                    lines: ['- `RRR_API_URL` (optional) sets the API base URL (default http://localhost:4000).'],
-                },
-            ],
-        }),
-    };
-}
-export const clientVariant = {
-    id: 'rrr-client',
-    label: 'rrr client',
-    defaultDir: 'packages/rrr-client',
-    summary: 'React Query-ready RRRoutes client bound to a shared contract import.',
-    keyFiles: ['src/index.ts', 'README.md'],
-    scripts: CLIENT_SCRIPTS,
-    notes: [
-        'Pick a contract from discovered workspace packages (or skip) during scaffolding.',
-        'Set the contract import via --contract or by editing src/index.ts.',
-        'Exports query client + typed route builders to plug into React apps.',
-    ],
-    async scaffold(ctx) {
-        const contractImport = ctx.contractName;
-        const files = await clientFiles(ctx.pkgName, contractImport, ctx.targetDir);
-        for (const [relative, contents] of Object.entries(files)) {
-            // eslint-disable-next-line no-await-in-loop
-            await writeFileIfMissing(ctx.targetDir, relative, contents);
-        }
-    },
-};
+export { clientVariant, CLIENT_KIND_OPTIONS, DEFAULT_CLIENT_KIND, normalizeClientKind, } from './client/shared.js';

package/dist/create-package/variants/docker.js

@@ -18,19 +18,29 @@ const DOCKER_SCRIPTS = [
     'docker:clean',
     'docker:reset',
 ];
+function sanitizeContainerName(name) {
+    const normalized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]/gi, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'rrr-service';
+    return normalized;
+}
 function dockerPackageJson(name, options) {
+    const image = `${name}:latest`;
+    const container = sanitizeContainerName(name);
+    const portVar = '${PORT:-3000}';
     return basePackageJson({
         name,
         scripts: baseScripts('tsx watch src/index.ts', {
             start: 'node dist/index.js',
-            'docker:cli': 'tsx scripts/docker.ts',
-            'docker:build': 'npm run docker:cli -- build',
-            'docker:up': 'npm run docker:cli -- up',
-            'docker:dev': 'npm run docker:cli -- dev',
-            'docker:logs': 'npm run docker:cli -- logs',
-            'docker:stop': 'npm run docker:cli -- stop',
-            'docker:clean': 'npm run docker:cli -- clean',
-            'docker:reset': 'npm run docker:cli -- reset',
+            'docker:build': `docker build -t ${image} .`,
+            'docker:up': `npm run docker:build && PORT=${portVar} docker run -d --rm -p ${portVar}:${portVar} --name ${container} ${image}`,
+            'docker:dev': `npm run docker:build && PORT=${portVar} docker run -d --rm -p ${portVar}:${portVar} --name ${container} ${image} && docker logs -f ${container}`,
+            'docker:logs': `docker logs -f ${container}`,
+            'docker:stop': `docker stop ${container}`,
+            'docker:clean': `docker stop ${container} || true; docker rm -f ${container} || true`,
+            'docker:reset': `npm run docker:clean && docker rmi -f ${image} || true`,
         }, { includePrepare: options?.includePrepare }),
         dependencies: {
             cors: '^2.8.5',
@@ -41,7 +51,6 @@ function dockerPackageJson(name, options) {
             '@types/cors': '^2.8.5',
             '@types/express': '^5.0.6',
             '@types/node': '^24.10.2',
-            'docker-cli-js': '^2.10.0',
         },
     });
 }
@@ -105,7 +114,6 @@ async function dockerFiles(pkgName, targetDir) {
         'package.json': dockerPackageJson(pkgName, { includePrepare }),
         'tsconfig.json': tsconfig,
         'src/index.ts': dockerIndexTs(),
-        'scripts/docker.ts': dockerCliScript(pkgName),
         '.dockerignore': DOCKER_DOCKERIGNORE,
         ...basePackageFiles(),
         Dockerfile: dockerDockerfile(),
@@ -143,145 +151,16 @@ async function dockerFiles(pkgName, targetDir) {
         }),
     };
 }
-function dockerCliScript(pkgName) {
-    return `#!/usr/bin/env tsx
-import { readFile } from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { Docker } from 'docker-cli-js'
-import { runHelperCli } from '@emeryld/manager/dist/helper-cli.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const pkgRoot = path.join(__dirname, '..')
-const pkgRaw = await readFile(path.join(pkgRoot, 'package.json'), 'utf8')
-const pkg = JSON.parse(pkgRaw) as { name?: string }
-const image = \`\${pkg.name ?? '${pkgName}'}:latest\`
-const container =
-  (pkg.name ?? '${pkgName}')
-    .replace(/[^a-z0-9]/gi, '-')
-    .replace(/^-+|-+$/g, '') || 'rrr-service'
-const port = process.env.PORT ?? '3000'
-const docker = new Docker({ spawnOptions: { stdio: 'inherit' } })
-
-async function safe(run: () => Promise<unknown>) {
-  try {
-    await run()
-  } catch (error: unknown) {
-    console.warn(error instanceof Error ? error.message : String(error))
-  }
-}
-
-function printHelp() {
-  console.log(
-    [
-      'Docker helper commands:',
-      '  build   -> docker build -t ${pkgName}:latest .',
-      '  up      -> build then run in detached mode',
-      '  dev     -> build, run, and tail logs',
-      '  run     -> run existing image detached',
-      '  logs    -> docker logs -f <container>',
-      '  stop    -> docker stop <container>',
-      '  clean   -> docker stop/rm <container>',
-      '  reset   -> clean container and remove image',
-    ].join('\\n'),
-  )
-}
-
-await runHelperCli({
-  title: 'Docker helper',
-  argv: process.argv.slice(2),
-  scripts: [
-    {
-      name: 'build',
-      emoji: '🔨',
-      description: 'docker build -t image .',
-      handler: () => docker.command(\`build -t \${image} .\`),
-    },
-    {
-      name: 'up',
-      emoji: '⬆️',
-      description: 'Build + run detached',
-      handler: async () => {
-        await docker.command(\`build -t \${image} .\`)
-        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-      },
-    },
-    {
-      name: 'dev',
-      emoji: '🛠️',
-      description: 'Build, run, tail logs',
-      handler: async () => {
-        await docker.command(\`build -t \${image} .\`)
-        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-        await docker.command(\`logs -f \${container}\`)
-      },
-    },
-    {
-      name: 'run',
-      emoji: '🏃',
-      description: 'Run existing image detached',
-      handler: () =>
-        docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`),
-    },
-    {
-      name: 'logs',
-      emoji: '📜',
-      description: 'Tail docker logs',
-      handler: () => docker.command(\`logs -f \${container}\`),
-    },
-    {
-      name: 'stop',
-      emoji: '🛑',
-      description: 'Stop container',
-      handler: () => docker.command(\`stop \${container}\`),
-    },
-    {
-      name: 'clean',
-      emoji: '🧹',
-      description: 'Stop + remove container',
-      handler: async () => {
-        await safe(() => docker.command(\`stop \${container}\`))
-        await safe(() => docker.command(\`rm -f \${container}\`))
-      },
-    },
-    {
-      name: 'reset',
-      emoji: '♻️',
-      description: 'Clean container and remove image',
-      handler: async () => {
-        await safe(() => docker.command(\`stop \${container}\`))
-        await safe(() => docker.command(\`rm -f \${container}\`))
-        await safe(() => docker.command(\`rmi -f \${image}\`))
-      },
-    },
-    {
-      name: 'help',
-      emoji: 'ℹ️',
-      description: 'Print commands',
-      handler: () => {
-        printHelp()
-      },
-    },
-  ],
-})
-`;
-}
 export const dockerVariant = {
     id: 'rrr-docker',
     label: 'dockerized service',
     defaultDir: 'packages/rrr-docker',
-    summary: 'Express service plus Dockerfile and a helper CLI for local runs.',
-    keyFiles: [
-        'src/index.ts',
-        'scripts/docker.ts',
-        'Dockerfile',
-        'README.md',
-    ],
+    summary: 'Express service plus Dockerfile and docker scripts for local runs.',
+    keyFiles: ['src/index.ts', 'Dockerfile', 'README.md'],
     scripts: DOCKER_SCRIPTS,
     notes: [
         'Use docker:dev or docker:up to build and run the container quickly.',
-        'scripts/docker.ts wraps common docker commands with consistent naming.',
+        'Manager CLI surfaces Docker helpers automatically when a Dockerfile is present.',
     ],
     async scaffold(ctx) {
         const files = await dockerFiles(ctx.pkgName, ctx.targetDir);

package/dist/create-package/variants/empty.js

@@ -17,6 +17,7 @@ function emptyPackageJson(name, options) {
             includePrepare: options?.includePrepare,
         }),
         devDependencies: {
+            '@types/node': '^24.10.2',
             ...BASE_LINT_DEV_DEPENDENCIES,
         },
     });

package/dist/create-package/variants/fullstack.js

@@ -1,6 +1,7 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, writeFileIfMissing, } from '../shared.js';
-import { clientVariant } from './client.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, workspaceRoot, writeFileIfMissing, } from '../shared.js';
+import { clientVariant, DEFAULT_CLIENT_KIND } from './client.js';
 import { serverVariant } from './server.js';
 import { dockerVariant } from './docker.js';
 import { contractVariant } from './contract.js';
@@ -46,8 +47,230 @@ function deriveDirs(rootDir, baseName) {
 function toPosixPath(value) {
     return value.split(path.sep).join('/');
 }
-function rootPackageJson(baseName) {
+async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeWorkspaceGlob(value) {
+    const unquoted = value.replace(/^['"]|['"]$/g, '').trim();
+    const normalized = toPosixPath(unquoted || '');
+    return normalized.replace(/^\.\//, '');
+}
+function globCoversCandidate(pattern, candidate) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    const normalizedCandidate = normalizeWorkspaceGlob(candidate);
+    if (!normalizedPattern || !normalizedCandidate)
+        return false;
+    if (normalizedPattern === normalizedCandidate)
+        return true;
+    if (normalizedPattern === '*' || normalizedPattern === '**')
+        return true;
+    if (normalizedPattern.endsWith('/**')) {
+        return normalizedCandidate.startsWith(normalizedPattern.slice(0, -3));
+    }
+    return false;
+}
+function patternsContain(patterns, candidate) {
+    return patterns.some((pattern) => globCoversCandidate(pattern, candidate));
+}
+function parsePnpmWorkspacePackages(raw) {
+    const packages = [];
+    const lines = raw.split(/\r?\n/);
+    const packagesIndex = lines.findIndex((line) => line.trim().startsWith('packages:'));
+    if (packagesIndex === -1)
+        return packages;
+    const baseIndent = lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? '';
+    for (let i = packagesIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const indent = line.match(/^(\s*)/)?.[1] ?? '';
+        if (indent.length <= baseIndent.length && !trimmed.startsWith('-'))
+            break;
+        if (!trimmed.startsWith('-')) {
+            if (indent.length <= baseIndent.length)
+                break;
+            continue;
+        }
+        const value = trimmed.slice(1).trim().replace(/^['"]|['"]$/g, '');
+        if (value)
+            packages.push(value);
+    }
+    return packages;
+}
+function insertIntoPnpmWorkspace(raw, pattern) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return { added: false, content: raw };
+    const existing = parsePnpmWorkspacePackages(raw);
+    if (patternsContain(existing, normalizedPattern)) {
+        return { added: false, content: raw };
+    }
+    const lines = raw.split(/\r?\n/);
+    const packagesIndex = lines.findIndex((line) => line.trim().startsWith('packages:'));
+    const entryLine = packagesIndex === -1
+        ? `  - '${normalizedPattern}'`
+        : `${lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? ''}  - '${normalizedPattern}'`;
+    if (packagesIndex === -1) {
+        const prefix = raw.trimEnd() ? `${raw.trimEnd()}\n` : '';
+        const content = `${prefix}packages:\n${entryLine}\n`;
+        return { added: true, content };
+    }
+    let insertAt = packagesIndex + 1;
+    const baseIndent = lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? '';
+    for (let i = packagesIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const indent = line.match(/^(\s*)/)?.[1] ?? '';
+        if (!trimmed) {
+            insertAt = i + 1;
+            continue;
+        }
+        if (indent.length <= baseIndent.length && !trimmed.startsWith('-')) {
+            insertAt = i;
+            break;
+        }
+        if (trimmed.startsWith('-')) {
+            insertAt = i + 1;
+            continue;
+        }
+        if (indent.length <= baseIndent.length) {
+            insertAt = i;
+            break;
+        }
+    }
+    lines.splice(insertAt, 0, entryLine);
+    const content = lines.join('\n').replace(/\n+$/, '\n');
+    return { added: true, content };
+}
+async function readPackageJsonWorkspaces(configPath) {
+    const raw = await readFile(configPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const workspaces = pkg.workspaces;
+    if (typeof workspaces === 'string')
+        return [workspaces];
+    if (Array.isArray(workspaces))
+        return workspaces.map(normalizeWorkspaceGlob).filter(Boolean);
+    if (workspaces && typeof workspaces === 'object' && 'packages' in workspaces) {
+        const packages = workspaces.packages;
+        if (typeof packages === 'string')
+            return [packages];
+        if (Array.isArray(packages))
+            return packages.map(normalizeWorkspaceGlob).filter(Boolean);
+    }
+    return undefined;
+}
+async function readPnpmWorkspace(configPath) {
+    const raw = await readFile(configPath, 'utf8');
+    return parsePnpmWorkspacePackages(raw).map(normalizeWorkspaceGlob).filter(Boolean);
+}
+async function findWorkspaceRoot(startDir) {
+    let current = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const pnpmPath = path.join(current, 'pnpm-workspace.yaml');
+        if (await pathExists(pnpmPath)) {
+            const patterns = await readPnpmWorkspace(pnpmPath);
+            return { rootDir: current, configPath: pnpmPath, type: 'pnpm-workspace', patterns };
+        }
+        const pkgPath = path.join(current, 'package.json');
+        if (await pathExists(pkgPath)) {
+            const patterns = await readPackageJsonWorkspaces(pkgPath);
+            if (patterns) {
+                return { rootDir: current, configPath: pkgPath, type: 'package-json', patterns };
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+async function updatePnpmWorkspaceFile(configPath, pattern) {
+    const raw = await readFile(configPath, 'utf8');
+    const { added, content } = insertIntoPnpmWorkspace(raw, pattern);
+    if (!added)
+        return false;
+    await writeFile(configPath, content, 'utf8');
+    return true;
+}
+async function updatePackageJsonWorkspaces(configPath, pattern) {
+    const raw = await readFile(configPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (typeof pkg.workspaces === 'string') {
+        if (globCoversCandidate(pkg.workspaces, normalizedPattern))
+            return false;
+        pkg.workspaces = [pkg.workspaces, normalizedPattern];
+    }
+    else if (Array.isArray(pkg.workspaces)) {
+        if (patternsContain(pkg.workspaces, normalizedPattern))
+            return false;
+        pkg.workspaces.push(normalizedPattern);
+    }
+    else if (pkg.workspaces && typeof pkg.workspaces === 'object') {
+        const packages = pkg.workspaces.packages;
+        if (Array.isArray(packages)) {
+            if (patternsContain(packages, normalizedPattern))
+                return false;
+            packages.push(normalizedPattern);
+        }
+        else {
+            pkg.workspaces.packages = [normalizedPattern];
+        }
+    }
+    else {
+        pkg.workspaces = [normalizedPattern];
+    }
+    const next = `${JSON.stringify(pkg, null, 2)}\n`;
+    await writeFile(configPath, next, 'utf8');
+    return true;
+}
+async function ensureWorkspacePattern(info, pattern) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (patternsContain(info.patterns, normalizedPattern))
+        return false;
+    const updated = info.type === 'pnpm-workspace'
+        ? await updatePnpmWorkspaceFile(info.configPath, normalizedPattern)
+        : await updatePackageJsonWorkspaces(info.configPath, normalizedPattern);
+    if (updated) {
+        info.patterns.push(normalizedPattern);
+        const rel = path.relative(workspaceRoot, info.configPath) || path.basename(info.configPath);
+        console.log(`  updated ${rel} (added workspace path ${normalizedPattern})`);
+    }
+    return updated;
+}
+function workspacePatternForPackagesRoot(workspaceRootDir, packagesRoot) {
+    const relative = toPosixPath(path.relative(workspaceRootDir, path.join(packagesRoot, '*')));
+    const normalized = relative || './packages/*';
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function workspacePatternForStackRoot(workspaceRootDir, stackRoot) {
+    const relative = toPosixPath(path.relative(workspaceRootDir, stackRoot));
+    const normalized = relative || '';
+    if (!normalized || normalized === '.')
+        return undefined;
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function rootPackageJson(baseName, options) {
     const dockerPackageDir = `packages/${baseName}-docker`;
+    const includeWorkspaces = options?.includeWorkspaces ?? true;
+    const workspacePatterns = includeWorkspaces && options?.workspacePatterns?.length
+        ? options.workspacePatterns
+        : includeWorkspaces
+            ? ['packages/*']
+            : undefined;
     return basePackageJson({
         name: `${baseName}-stack`,
         private: true,
@@ -73,12 +296,16 @@ function rootPackageJson(baseName) {
         },
         devDependencies: { ...BASE_LINT_DEV_DEPENDENCIES },
         extraFields: {
-            workspaces: ['packages/*'],
+            ...(workspacePatterns ? { workspaces: workspacePatterns } : {}),
         },
     });
 }
-function rootPnpmWorkspace() {
-    return "packages:\n  - 'packages/*'\n";
+function rootPnpmWorkspace(patterns) {
+    const lines = ['packages:'];
+    patterns.forEach((pattern) => {
+        lines.push(`  - '${pattern}'`);
+    });
+    return `${lines.join('\n')}\n`;
 }
 function rootTsconfigBase(baseName, names) {
     const paths = {
@@ -142,10 +369,17 @@ volumes:
   db-data:
 `;
 }
-async function scaffoldRootFiles(baseDir, baseName, names, dirs) {
+async function scaffoldRootFiles(baseDir, baseName, names, dirs, options) {
+    const includeWorkspaceFiles = options?.includeWorkspaceFiles ?? true;
+    const workspacePatterns = options?.workspacePatterns?.filter(Boolean) ?? ['packages/*'];
     const files = {
-        'package.json': rootPackageJson(baseName),
-        'pnpm-workspace.yaml': rootPnpmWorkspace(),
+        'package.json': rootPackageJson(baseName, {
+            includeWorkspaces: includeWorkspaceFiles,
+            workspacePatterns,
+        }),
+        ...(includeWorkspaceFiles
+            ? { 'pnpm-workspace.yaml': rootPnpmWorkspace(workspacePatterns) }
+            : {}),
         'docker-compose.yml': stackComposeYaml(),
         'tsconfig.base.json': rootTsconfigBase(baseName, names),
         'tsconfig.json': rootSolutionTsconfig(dirs),
@@ -174,13 +408,30 @@ export const fullstackVariant = {
     notes: [
         'Generates four packages and a workspace root; great starting point when you need the whole stack.',
         'Use --name to control the workspace prefix (default is the target folder name).',
+        'If you scaffold inside an existing workspace, the root workspace config is updated instead of nesting a new one.',
     ],
     async scaffold(ctx) {
         const baseName = ctx.pkgName;
         const names = deriveNames(baseName);
         const dirs = deriveDirs(ctx.targetDir, baseName);
+        const existingWorkspace = await findWorkspaceRoot(dirs.root);
+        const workspaceRootDir = existingWorkspace?.rootDir ?? dirs.root;
+        const workspacePattern = workspacePatternForPackagesRoot(workspaceRootDir, dirs.packagesRoot);
+        const stackRootPattern = workspacePatternForStackRoot(workspaceRootDir, dirs.root);
+        const workspacePatterns = stackRootPattern
+            ? [workspacePattern, stackRootPattern]
+            : [workspacePattern];
+        if (existingWorkspace) {
+            for (const pattern of workspacePatterns) {
+                // eslint-disable-next-line no-await-in-loop
+                await ensureWorkspacePattern(existingWorkspace, pattern);
+            }
+        }
         // Root workspace files
-        await scaffoldRootFiles(dirs.root, baseName, names, dirs);
+        await scaffoldRootFiles(dirs.root, baseName, names, dirs, {
+            includeWorkspaceFiles: !existingWorkspace,
+            workspacePatterns,
+        });
         // Contract package (reuse contract variant)
         await contractVariant.scaffold({
             targetDir: dirs.contract,
@@ -197,6 +448,7 @@ export const fullstackVariant = {
             targetDir: dirs.client,
             pkgName: names.client,
             contractName: names.contract,
+            clientKind: ctx.clientKind ?? DEFAULT_CLIENT_KIND,
         });
         // Docker helper package (reuse docker variant)
         await dockerVariant.scaffold({