create-aiko 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# create-aiko
+
+CLI to create a new aiko-boot scaffold project (monorepo: api, admin, mobile, shared, optionally shared-auth).
+
+## Usage
+
+Published package usage:
+
+```bash
+pnpm dlx create-aiko my-app
+```
+
+Repository-local usage:
+
+```bash
+pnpm run create
+node packages/aiko-boot-create/dist/cli.js
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `[targetDir]` | Target directory for the new project. Default: `<cwd>/<projectName>` |
+| `-n, --name <name>` | Project name, used as npm scope (e.g. `my-app` → `@my-app/*`) |
+| `--with-base-system` | Include base system: login, shared-auth, user/menu management (later) |
+| `--no-base-system` | Bare project without login/auth (default when not specified) |
+| `--template-dir <dir>` | Path to scaffold template. Default: bundled template in npm package; if missing, fallback to `<cwd>/scaffold` |
+
+## Base system vs bare
+
+- **With base system** (`--with-base-system`): Copies full scaffold including `shared-auth`, auth controller/service/dto, user entity/mapper, init-db with `sys_user`, login pages and protected routes in admin/mobile.
+- **Bare** (`--no-base-system`): Same monorepo structure (api, admin, mobile, shared) but no `shared-auth`, no auth-related files in api, no login UI or protected routes; shared has no `AUTH_STORAGE_KEY`.
+
+## After generation
+
+1. `cd <targetDir>`
+2. `pnpm install`
+3. If base system was included: `pnpm init-db`
+4. `pnpm dev`
+
+## Build
+
+```bash
+pnpm build
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * create-aiko CLI
+ * Create a new aiko-boot scaffold project (monorepo: api, admin, mobile, shared[, shared-auth]).
+ */
+import { createCommand } from './create.js';
+createCommand();

package/dist/create.d.ts

@@ -0,0 +1 @@
+export declare function createCommand(): void;

package/dist/create.js

@@ -0,0 +1,174 @@
+import { program } from 'commander';
+import * as readline from 'readline';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+import { createScaffold } from './scaffold.js';
+const SCAFFOLD_DIR_NAME = 'scaffold';
+const PACKAGE_TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../template');
+function getTemplateDir(cwd) {
+    const cwdTemplateDir = path.join(cwd, SCAFFOLD_DIR_NAME);
+    if (fs.existsSync(cwdTemplateDir)) {
+        return cwdTemplateDir;
+    }
+    return PACKAGE_TEMPLATE_DIR;
+}
+function prompt(question, defaultValue) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        const suffix = defaultValue !== undefined ? ` (${defaultValue})` : '';
+        rl.question(`${question}${suffix}: `, (answer) => {
+            rl.close();
+            resolve((answer.trim() || (defaultValue ?? '')).trim());
+        });
+    });
+}
+function promptConfirm(question, defaultValue) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const hint = defaultValue ? 'Y/n' : 'y/N';
+    return new Promise((resolve) => {
+        rl.question(`${question} [${hint}]: `, (answer) => {
+            rl.close();
+            const lower = answer.trim().toLowerCase();
+            if (lower === '')
+                resolve(defaultValue);
+            else
+                resolve(lower === 'y' || lower === 'yes');
+        });
+    });
+}
+/** Normalize project name to valid npm scope (lowercase, no spaces). */
+function toScope(name) {
+    const normalized = name
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || 'my-app';
+}
+const RESERVED_SCOPES = new Set([
+    'node',
+    'npm',
+    'js',
+    'javascript',
+    'typescript',
+    'react',
+    'vue',
+    'angular',
+    'core',
+    'admin',
+    'root',
+    'system',
+]);
+function assertValidScope(scope) {
+    if (!scope) {
+        console.error('Invalid scope: empty value. Please provide a non-empty project name.');
+        process.exit(1);
+    }
+    if (RESERVED_SCOPES.has(scope)) {
+        console.error(`Invalid scope "${scope}": this name is reserved. Please choose a different project name.`);
+        process.exit(1);
+    }
+}
+/** Show destination default as relative path when under cwd (e.g. "./my-app"). */
+function defaultDirDisplay(cwd, absoluteDir) {
+    const relative = path.relative(cwd, absoluteDir);
+    if (relative && !relative.startsWith('..') && relative !== absoluteDir) {
+        return relative.startsWith('.') ? relative : `./${relative}`;
+    }
+    return absoluteDir;
+}
+export function createCommand() {
+    program
+        .name('create-aiko')
+        .description('Create a new aiko-boot scaffold project (monorepo: api, admin, mobile, shared)')
+        .version('0.1.0')
+        .argument('[projectNameOrPath]', 'Project name or path (e.g. my-app or ./my-app; default: prompt)')
+        .option('-n, --name <name>', 'Project name (folder + npm scope, e.g. my-app)')
+        .option('--with-base-system', 'Include base system: login, shared-auth, user/menu management later')
+        .option('--no-base-system', 'Bare project without login/auth (default when not specified)')
+        .option('--template-dir <dir>', 'Path to scaffold template (default: package bundled template, fallback to <cwd>/scaffold)')
+        .action(async (targetDirArg, options) => {
+        const cwd = process.cwd();
+        let projectName = options.name;
+        let withBaseSystem;
+        let targetDir;
+        const templateDir = options.templateDir
+            ? path.resolve(cwd, options.templateDir)
+            : getTemplateDir(cwd);
+        if (!projectName || !targetDirArg) {
+            console.log('\n create-aiko\n');
+            const defaultDir = targetDirArg
+                ? path.resolve(cwd, targetDirArg)
+                : path.join(cwd, projectName ? toScope(projectName) : 'my-app');
+            if (!projectName) {
+                const defaultName = targetDirArg ? path.basename(path.resolve(cwd, targetDirArg)) : 'my-app';
+                projectName = await prompt('Project name (e.g. my-app)', defaultName);
+                if (!projectName) {
+                    console.error('Project name is required.');
+                    process.exit(1);
+                }
+            }
+            if (!targetDirArg) {
+                const dirPromptDefault = defaultDirDisplay(cwd, defaultDir);
+                const dirAnswer = await prompt('Destination (folder path for the project)', dirPromptDefault);
+                targetDir = path.resolve(cwd, dirAnswer || defaultDir);
+            }
+            else {
+                targetDir = path.resolve(cwd, targetDirArg);
+            }
+            if (options.withBaseSystem === true)
+                withBaseSystem = true;
+            else if (options.baseSystem === false)
+                withBaseSystem = false;
+            else {
+                withBaseSystem = await promptConfirm('Include base system (login, shared-auth, user/menu management)?', false);
+            }
+        }
+        else {
+            projectName = projectName.trim();
+            targetDir = path.resolve(cwd, targetDirArg);
+            // --with-base-system -> true; --no-base-system -> baseSystem false; neither -> default bare (false)
+            withBaseSystem = options.baseSystem === false ? false : options.withBaseSystem === true;
+        }
+        const scope = toScope(projectName);
+        assertValidScope(scope);
+        // If target dir exists and is not empty, create project in a subdir named after scope
+        if (await fs.pathExists(targetDir)) {
+            const files = await fs.readdir(targetDir);
+            if (files.length > 0) {
+                const subDir = path.join(targetDir, scope);
+                console.log(`\nDestination is not empty; creating project in: ${subDir}`);
+                targetDir = subDir;
+            }
+        }
+        console.log('\nOptions:');
+        console.log('  Destination:', targetDir);
+        console.log('  Scope:', scope, `(@${scope}/*)`);
+        console.log('  With base system:', withBaseSystem);
+        console.log('  Template:', templateDir);
+        try {
+            await createScaffold({
+                templateDir,
+                targetDir,
+                scope,
+                withBaseSystem,
+            });
+            console.log('\nDone. Next steps:');
+            console.log(`  cd ${targetDir}`);
+            console.log('  pnpm install');
+            if (withBaseSystem) {
+                console.log('  pnpm init-db   # first time');
+                console.log('  pnpm run rebuild:sqlite   # if api fails with "bindings file", build better-sqlite3 native');
+            }
+            console.log('  pnpm dev');
+        }
+        catch (err) {
+            console.error(err);
+            process.exit(1);
+        }
+    });
+    program.parse();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createScaffold, type CreateOptions } from './scaffold.js';
+export { createCommand } from './create.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createScaffold } from './scaffold.js';
+export { createCommand } from './create.js';

package/dist/scaffold.d.ts

@@ -0,0 +1,7 @@
+export type CreateOptions = {
+    templateDir: string;
+    targetDir: string;
+    scope: string;
+    withBaseSystem: boolean;
+};
+export declare function createScaffold(options: CreateOptions): Promise<void>;

package/dist/scaffold.js

@@ -0,0 +1,310 @@
+import path from 'path';
+import fs from 'fs-extra';
+const COPY_IGNORE = [
+    'node_modules',
+    '.next',
+    'dist',
+    '.pnpm-store',
+    '*.tsbuildinfo',
+    '.vite',
+    '*.log',
+];
+/** Paths to skip when withBaseSystem is false (relative to scaffold root). */
+const SKIP_WHEN_BARE = [
+    'packages/shared-auth',
+    'packages/api/src/controller/auth.controller.ts',
+    'packages/api/src/service/auth.service.ts',
+    'packages/api/src/dto/auth.dto.ts',
+    'packages/api/src/entity/user.entity.ts',
+    'packages/api/src/mapper/user.mapper.ts',
+    'packages/mobile/src/components/LoginForm.tsx',
+    'packages/mobile/src/pages/LoginPage.tsx',
+    'packages/mobile/src/routes/ProtectedRoute.tsx',
+    'packages/admin/src/components/LoginForm.tsx',
+];
+const FRAMEWORK_SCOPE = '@ai-partner-x/';
+/** Registry version for @ai-partner-x/*，发布到中央仓库后从此版本安装；本地开发通过 pnpm.overrides 覆盖 */
+const FRAMEWORK_REGISTRY_VERSION = '^0.1.0';
+/** 脚手架中可能用到的框架包名（scope 后缀），用于生成 overrides */
+const FRAMEWORK_PACKAGE_NAMES = [
+    'aiko-boot',
+    'aiko-boot-starter-cache',
+    'aiko-boot-starter-orm',
+    'aiko-boot-starter-validation',
+    'aiko-boot-starter-web',
+    'aiko-boot-starter-storage',
+    'aiko-boot-starter-security',
+];
+export async function createScaffold(options) {
+    const { templateDir, targetDir, scope, withBaseSystem } = options;
+    const frameworkRoot = path.dirname(templateDir);
+    if (!(await fs.pathExists(templateDir))) {
+        throw new Error(`Template directory not found: ${templateDir}. Run from ai-frist-framework root (scaffold/ must exist).`);
+    }
+    if (await fs.pathExists(targetDir)) {
+        const files = await fs.readdir(targetDir);
+        if (files.length > 0) {
+            throw new Error(`Target directory already exists and is not empty: ${targetDir}`);
+        }
+    }
+    await fs.ensureDir(targetDir);
+    await copyRecursive(templateDir, templateDir, targetDir, withBaseSystem);
+    await replaceScopeInFiles(targetDir, scope);
+    // 依赖写 registry 版本，便于将来从中央仓库安装；本地开发通过根目录 pnpm.overrides 覆盖
+    await replaceFrameworkDepsWithRegistryVersion(targetDir);
+    await addFrameworkOverridesInRoot(targetDir, frameworkRoot);
+    // 使生成的项目成为独立 pnpm workspace，在项目目录内执行 pnpm 时不会回溯到父仓库
+    await fs.writeFile(path.join(targetDir, 'pnpm-workspace.yaml'), `packages:
+  - 'packages/*'
+`, 'utf-8');
+    if (!withBaseSystem) {
+        await writeBareTemplates(targetDir, scope);
+    }
+    // 再次替换，确保子包中 @ai-partner-x/* 均为 registry 版本（与根 pnpm.overrides 配合）
+    await replaceFrameworkDepsWithRegistryVersion(targetDir);
+}
+/** 将各 package.json 中 @ai-partner-x/* 的 workspace: 协议改为 registry 版本（如 ^0.1.0），与根目录 pnpm.overrides 配合使用 */
+async function replaceFrameworkDepsWithRegistryVersion(targetDir) {
+    const packageJsonPaths = [];
+    async function collect(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.name === 'package.json') {
+                packageJsonPaths.push(full);
+            }
+            else if (e.isDirectory() && e.name !== 'node_modules' && !e.name.startsWith('.')) {
+                await collect(full);
+            }
+        }
+    }
+    await collect(targetDir);
+    for (const pkgPath of packageJsonPaths) {
+        const pkg = await fs.readJson(pkgPath);
+        let changed = false;
+        for (const key of ['dependencies', 'devDependencies']) {
+            if (!pkg[key])
+                continue;
+            for (const [name, value] of Object.entries(pkg[key])) {
+                const isWorkspaceProtocol = typeof value === 'string' && (value === 'workspace:*' || value.startsWith('workspace:'));
+                if (name.startsWith(FRAMEWORK_SCOPE) && isWorkspaceProtocol) {
+                    pkg[key][name] = FRAMEWORK_REGISTRY_VERSION;
+                    changed = true;
+                }
+            }
+        }
+        if (changed)
+            await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    }
+}
+/** 在根 package.json 中增加 pnpm.overrides，指向本地框架路径；需要从中央仓库安装时删除该段即可 */
+async function addFrameworkOverridesInRoot(targetDir, frameworkRoot) {
+    const frameworkPackagesDir = path.join(frameworkRoot, 'packages');
+    if (!(await fs.pathExists(frameworkPackagesDir))) {
+        return;
+    }
+    const rootPkgPath = path.join(targetDir, 'package.json');
+    const rootPkg = await fs.readJson(rootPkgPath);
+    const relativeToFramework = path.relative(targetDir, frameworkRoot).replace(/\\/g, '/');
+    const filePrefix = relativeToFramework.startsWith('.') ? relativeToFramework : `./${relativeToFramework}`;
+    const overrides = {};
+    for (const pkgName of FRAMEWORK_PACKAGE_NAMES) {
+        overrides[`${FRAMEWORK_SCOPE}${pkgName}`] = `file:${filePrefix}/packages/${pkgName}`;
+    }
+    rootPkg.pnpm = { ...rootPkg.pnpm, overrides };
+    await fs.writeJson(rootPkgPath, rootPkg, { spaces: 2 });
+}
+function shouldIgnore(name) {
+    if (COPY_IGNORE.some((x) => x.startsWith('*') && name.endsWith(x.slice(1))))
+        return true;
+    if (COPY_IGNORE.includes(name))
+        return true;
+    return false;
+}
+function shouldSkipWhenBare(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    return SKIP_WHEN_BARE.some((skip) => normalized === skip || normalized.startsWith(skip + '/'));
+}
+async function copyRecursive(templateRoot, src, dest, withBaseSystem) {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        const relativePath = path.relative(templateRoot, srcPath).replace(/\\/g, '/');
+        if (shouldIgnore(entry.name))
+            continue;
+        if (!withBaseSystem && shouldSkipWhenBare(relativePath))
+            continue;
+        if (entry.isDirectory()) {
+            await fs.ensureDir(destPath);
+            await copyRecursive(templateRoot, srcPath, destPath, withBaseSystem);
+        }
+        else {
+            await fs.copy(srcPath, destPath);
+        }
+    }
+}
+async function replaceScopeInFiles(dir, scope) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory() && !shouldIgnore(entry.name)) {
+            await replaceScopeInFiles(full, scope);
+        }
+        else if (entry.isFile()) {
+            const ext = path.extname(entry.name).toLowerCase();
+            if (!['.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.mjs', '.cjs', '.css', '.html'].includes(ext))
+                continue;
+            let content = await fs.readFile(full, 'utf-8');
+            const before = content;
+            content = content.replace(/@scaffold\//g, `@${scope}/`);
+            content = content.replace(/"@scaffold\//g, `"@${scope}/`);
+            content = content.replace(/scaffold-monorepo/g, `${scope}-monorepo`);
+            content = content.replace(/--filter "@scaffold\/\*"/g, `--filter "@${scope}/*"`);
+            content = content.replace(/-F @scaffold\//g, `-F @${scope}/`);
+            if (content !== before)
+                await fs.writeFile(full, content, 'utf-8');
+        }
+    }
+}
+/** Write bare (no auth) template files when withBaseSystem is false. */
+async function writeBareTemplates(targetDir, scope) {
+    const packagesDir = path.join(targetDir, 'packages');
+    await fs.writeFile(path.join(packagesDir, 'api/src/scripts/init-db.ts'), `/**
+ * Initialize SQLite database (bare scaffold, no user table).
+ */
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+// @ts-expect-error sql.js has no types
+import initSqlJs from 'sql.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dbPath = join(__dirname, '../../data/app.db');
+
+console.log('📁 Database path:', dbPath);
+
+const SQL = await initSqlJs();
+const db = new SQL.Database();
+
+// Add your tables here when needed.
+
+const data = db.export();
+db.close();
+
+const dir = dirname(dbPath);
+if (!existsSync(dir)) {
+  mkdirSync(dir, { recursive: true });
+}
+writeFileSync(dbPath, Buffer.from(data));
+
+console.log('\\n🎉 Database initialization complete!');
+`, 'utf-8');
+    await fs.writeFile(path.join(packagesDir, 'shared/src/constants.ts'), `/** API base URL env key (admin: VITE_API_URL, mobile: etc.) */
+export const API_BASE_URL_KEY = 'API_URL';
+
+/** Default API base URL */
+export const DEFAULT_API_BASE_URL = 'http://localhost:3001';
+`, 'utf-8');
+    await fs.writeFile(path.join(packagesDir, 'shared/src/index.ts'), `export {
+  API_BASE_URL_KEY,
+  DEFAULT_API_BASE_URL,
+} from './constants';
+`, 'utf-8');
+    const mobileMain = `import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+import './app/globals.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);
+`;
+    await fs.writeFile(path.join(packagesDir, 'mobile/src/main.tsx'), mobileMain, 'utf-8');
+    const mobileRoutesIndex = `import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
+import { HomePage } from '@/pages/HomePage';
+import { ROUTES } from './routes';
+
+export function AppRouter() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path={ROUTES.HOME} element={<HomePage />} />
+        <Route path="*" element={<Navigate to={ROUTES.HOME} replace />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}
+`;
+    await fs.writeFile(path.join(packagesDir, 'mobile/src/routes/index.tsx'), mobileRoutesIndex, 'utf-8');
+    await fs.writeFile(path.join(packagesDir, 'mobile/src/routes/routes.ts'), `export const ROUTES = {
+  HOME: '/',
+} as const;
+
+export type RoutePath = (typeof ROUTES)[keyof typeof ROUTES];
+`, 'utf-8');
+    const homePage = `/**
+ * Mobile home page (bare scaffold).
+ */
+export function HomePage() {
+  return (
+    <div className="min-h-screen bg-gray-50 flex flex-col">
+      <header className="flex items-center justify-between px-4 py-3 bg-white border-b border-gray-200 safe-area-top">
+        <span className="text-lg font-medium text-gray-800">AIKO-BOOT</span>
+      </header>
+      <main className="flex-1 flex flex-col items-center justify-center px-4">
+        <h1 className="text-2xl font-semibold text-gray-900 mb-1">AIKO-BOOT</h1>
+        <p className="text-gray-500 text-sm">Scaffold ready. Add your pages.</p>
+      </main>
+    </div>
+  );
+}
+`;
+    await fs.writeFile(path.join(packagesDir, 'mobile/src/pages/HomePage.tsx'), homePage, 'utf-8');
+    await fs.writeFile(path.join(packagesDir, 'mobile/src/pages/index.ts'), `export { HomePage } from './HomePage';
+`, 'utf-8');
+    const adminMain = `import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);
+`;
+    await fs.writeFile(path.join(packagesDir, 'admin/src/main.tsx'), adminMain, 'utf-8');
+    const adminApp = `export default function App() {
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-gray-100">
+      <p className="text-gray-600">Scaffold Admin — add your pages.</p>
+    </div>
+  );
+}
+`;
+    await fs.writeFile(path.join(packagesDir, 'admin/src/App.tsx'), adminApp, 'utf-8');
+    const sharedAuthPkg = `@${scope}/shared-auth`;
+    const mobilePkgPath = path.join(packagesDir, 'mobile/package.json');
+    const mobilePkg = await fs.readJson(mobilePkgPath);
+    if (mobilePkg.dependencies) {
+        delete mobilePkg.dependencies[sharedAuthPkg];
+        mobilePkg.dependencies = Object.fromEntries(Object.entries(mobilePkg.dependencies).filter(([k]) => k !== sharedAuthPkg));
+    }
+    await fs.writeJson(mobilePkgPath, mobilePkg, { spaces: 2 });
+    const adminPkgPath = path.join(packagesDir, 'admin/package.json');
+    const adminPkg = await fs.readJson(adminPkgPath);
+    if (adminPkg.dependencies) {
+        delete adminPkg.dependencies[sharedAuthPkg];
+        adminPkg.dependencies = Object.fromEntries(Object.entries(adminPkg.dependencies).filter(([k]) => k !== sharedAuthPkg));
+    }
+    await fs.writeJson(adminPkgPath, adminPkg, { spaces: 2 });
+    const mobileVitePath = path.join(packagesDir, 'mobile/vite.config.ts');
+    if (await fs.pathExists(mobileVitePath)) {
+        let viteContent = await fs.readFile(mobileVitePath, 'utf-8');
+        viteContent = viteContent.replace(/\s*exclude:\s*\[\s*'@[^']+\/shared-auth'\s*\],?\s*/g, '\n');
+        await fs.writeFile(mobileVitePath, viteContent, 'utf-8');
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-aiko",
+  "version": "0.1.0",
+  "description": "CLI to create aiko-boot scaffold project (monorepo with api, admin, mobile, shared)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "create-aiko": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "build": "tsc && node ./scripts/build-template.mjs",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/template/README.md

@@ -0,0 +1,63 @@
+# Scaffold Monorepo
+
+用于发布项目初始化模板的干净脚手架，包含：
+
+- `api`
+- `admin`
+- `mobile`
+- `shared`
+- `shared-auth`
+
+这份模板聚焦在“可运行项目骨架”和“可复用后台组件能力”，不再承载需求驱动生成器、spec 规则和实验性产物。
+
+## 快速启动
+
+```bash
+cd scaffold
+pnpm install
+pnpm init-db
+pnpm dev
+```
+
+默认地址：
+
+- API: `http://localhost:3001/api`
+- Admin: `http://localhost:5173`
+- Mobile: `http://localhost:3002`
+
+默认测试账号：
+
+- 用户名：`admin`
+- 密码：`admin123`
+
+## 目录结构
+
+```text
+scaffold/
+├── packages/
+│   ├── api
+│   ├── admin
+│   ├── mobile
+│   ├── shared
+│   └── shared-auth
+├── scripts/
+└── package.json
+```
+
+## 常用命令
+
+```bash
+pnpm dev
+pnpm dev:api
+pnpm dev:admin
+pnpm dev:mobile
+pnpm init-db
+pnpm build
+pnpm lint
+```
+
+如果 `better-sqlite3` 原生模块异常，可执行：
+
+```bash
+pnpm run rebuild:sqlite
+```