@ai-partner-x/aiko-boot-cli 0.1.4

package/dist/core/workspace.js

@@ -0,0 +1,141 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { loadProjectConfig, saveProjectConfig, } from './project-config.js';
+import { getFrameworkRegistryVersion } from './framework-version.js';
+const FRAMEWORK_SCOPE = '@ai-partner-x/';
+export async function ensurePnpmWorkspace(rootDir) {
+    const workspacePath = path.join(rootDir, 'pnpm-workspace.yaml');
+    if (await fs.pathExists(workspacePath))
+        return;
+    await fs.writeFile(workspacePath, `packages:
+  - 'packages/*'
+`, 'utf-8');
+}
+export async function withProjectConfig(rootDir, updater) {
+    const existing = (await loadProjectConfig(rootDir)) ?? {
+        version: 1,
+        apps: [],
+        apis: [],
+    };
+    const next = (updater(existing) ?? existing);
+    await saveProjectConfig(rootDir, next);
+    return next;
+}
+/**
+ * 根据 .aiko-boot.json 的配置，同步根目录下的 package.json：
+ * - 补充 name/version/private
+ * - 生成常用 scripts（dev / build / lint / dev:api 等）
+ * - 便于后续在根目录直接运行 pnpm 脚本
+ */
+export async function syncRootPackageJson(rootDir) {
+    const config = await loadProjectConfig(rootDir);
+    if (!config)
+        return;
+    const rootPkgPath = path.join(rootDir, 'package.json');
+    let pkg = {};
+    if (await fs.pathExists(rootPkgPath)) {
+        pkg = await fs.readJson(rootPkgPath);
+    }
+    const scope = config.scope ?? 'scaffold';
+    if (!pkg.name) {
+        pkg.name = `${scope}-monorepo`;
+    }
+    if (pkg.private === undefined) {
+        pkg.private = true;
+    }
+    if (!pkg.version) {
+        pkg.version = '0.1.0';
+    }
+    const scripts = pkg.scripts ?? {};
+    // 通用脚本：对所有 @<scope>/* 包执行 dev / build / lint
+    scripts.dev = `pnpm -r --parallel --filter "@${scope}/*" dev`;
+    scripts.build = `pnpm -r --filter "@${scope}/*" build`;
+    scripts.lint = `pnpm -r --filter "@${scope}/*" lint`;
+    // API 相关脚本：只针对 name === 'api' 的服务，保持与 scaffold 模板一致
+    const api = (config.apis ?? []).find((x) => x.name === 'api');
+    if (api) {
+        const apiPkgName = `@${scope}/${api.name}`;
+        scripts['dev:api'] = `pnpm -F ${apiPkgName} dev`;
+        scripts['build:api'] = `pnpm -F ${apiPkgName} build`;
+        scripts['start:api'] = `pnpm -F ${apiPkgName} start`;
+        scripts['init-db'] = `pnpm -F ${apiPkgName} init-db`;
+    }
+    // Admin / Mobile 应用脚本：按照 type 分类
+    const apps = config.apps ?? [];
+    const adminApp = apps.find((x) => x.type === 'admin');
+    if (adminApp) {
+        const adminPkgName = `@${scope}/${adminApp.name}`;
+        scripts['dev:admin'] = `pnpm -F ${adminPkgName} dev`;
+        scripts['build:admin'] = `pnpm -F ${adminPkgName} build`;
+    }
+    const mobileApp = apps.find((x) => x.type === 'mobile');
+    if (mobileApp) {
+        const mobilePkgName = `@${scope}/${mobileApp.name}`;
+        scripts['dev:mobile'] = `pnpm -F ${mobilePkgName} dev`;
+        scripts['build:mobile'] = `pnpm -F ${mobilePkgName} build`;
+    }
+    pkg.scripts = scripts;
+    // 与 scaffold-default 对齐：只在未设置时提供默认值
+    const pnpmConfig = pkg.pnpm ?? {};
+    if (!pnpmConfig.onlyBuiltDependencies) {
+        pnpmConfig.onlyBuiltDependencies = ['better-sqlite3'];
+    }
+    // 清理旧的本地框架覆盖（如 file:.../packages/），避免在中央仓库安装时仍引用本地库。
+    if (pnpmConfig.overrides && typeof pnpmConfig.overrides === 'object') {
+        for (const [k, v] of Object.entries(pnpmConfig.overrides)) {
+            if (k.startsWith(FRAMEWORK_SCOPE) && typeof v === 'string' && v.startsWith('file:')) {
+                delete pnpmConfig.overrides[k];
+            }
+        }
+        if (Object.keys(pnpmConfig.overrides).length === 0) {
+            delete pkg.pnpm.overrides;
+        }
+    }
+    pkg.pnpm = pnpmConfig;
+    // Ensure all generated framework deps use registry versions (not `workspace:*`),
+    // so the scaffold can be used outside of this monorepo.
+    await replaceFrameworkDepsWithRegistryVersion(rootDir);
+    await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
+}
+async function replaceFrameworkDepsWithRegistryVersion(rootDir) {
+    const FRAMEWORK_REGISTRY_VERSION = await getFrameworkRegistryVersion();
+    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 === 'node_modules')
+                continue;
+            if (e.isDirectory()) {
+                if (e.name.startsWith('.'))
+                    continue;
+                await collect(full);
+            }
+            else if (e.isFile() && e.name === 'package.json') {
+                packageJsonPaths.push(full);
+            }
+        }
+    }
+    await collect(path.join(rootDir, 'packages'));
+    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])) {
+                if (!name.startsWith(FRAMEWORK_SCOPE))
+                    continue;
+                if (typeof value !== 'string')
+                    continue;
+                if (value.startsWith('file:') || value.startsWith('link:'))
+                    continue;
+                pkg[key][name] = FRAMEWORK_REGISTRY_VERSION;
+                changed = true;
+            }
+        }
+        if (changed) {
+            await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+        }
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,2 @@
+export { runCli } from './cli.js';
+export { createScaffold } from './scaffold.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,272 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { getFrameworkRegistryVersion } from './core/framework-version.js';
+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/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/';
+export async function createScaffold(options) {
+    const { templateDir, targetDir, scope, withBaseSystem } = options;
+    if (!(await fs.pathExists(templateDir))) {
+        throw new Error(`Template directory not found: ${templateDir}. ` +
+            'You can specify a custom template with --template-dir, or use the built-in templates.');
+    }
+    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);
+    // 使生成的项目成为独立 pnpm workspace，在项目目录内执行 pnpm 时不会回溯到父仓库
+    await fs.writeFile(path.join(targetDir, 'pnpm-workspace.yaml'), `packages:
+  - 'packages/*'
+`, 'utf-8');
+    if (!withBaseSystem) {
+        await writeBareTemplates(targetDir);
+    }
+    // 再次替换，确保子包中 @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 FRAMEWORK_REGISTRY_VERSION = await getFrameworkRegistryVersion();
+    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])) {
+                if (!name.startsWith(FRAMEWORK_SCOPE))
+                    continue;
+                if (typeof value !== 'string')
+                    continue;
+                // 只要是框架包，一律写 registry 版本范围（除非显式用 file:/link: 做本地调试）
+                if (value.startsWith('file:') || value.startsWith('link:'))
+                    continue;
+                pkg[key][name] = FRAMEWORK_REGISTRY_VERSION;
+                changed = true;
+            }
+        }
+        if (changed)
+            await fs.writeJson(pkgPath, pkg, { 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) {
+    const packagesDir = path.join(targetDir, 'packages');
+    // api init-db
+    const apiInitDbPath = path.join(packagesDir, 'api/src/scripts/init-db.ts');
+    await fs.ensureDir(path.dirname(apiInitDbPath));
+    await fs.writeFile(apiInitDbPath, `/**
+ * 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');
+    // mobile main / routes / pages
+    const mobileMainPath = path.join(packagesDir, 'mobile/src/main.tsx');
+    await fs.ensureDir(path.dirname(mobileMainPath));
+    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(mobileMainPath, mobileMain, 'utf-8');
+    const mobileRoutesIndexPath = path.join(packagesDir, 'mobile/src/routes/index.tsx');
+    await fs.ensureDir(path.dirname(mobileRoutesIndexPath));
+    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(mobileRoutesIndexPath, mobileRoutesIndex, 'utf-8');
+    const mobileRoutesPath = path.join(packagesDir, 'mobile/src/routes/routes.ts');
+    await fs.ensureDir(path.dirname(mobileRoutesPath));
+    await fs.writeFile(mobileRoutesPath, `export const ROUTES = {
+  HOME: '/',
+} as const;
+
+export type RoutePath = (typeof ROUTES)[keyof typeof ROUTES];
+`, 'utf-8');
+    const mobileHomePagePath = path.join(packagesDir, 'mobile/src/pages/HomePage.tsx');
+    await fs.ensureDir(path.dirname(mobileHomePagePath));
+    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(mobileHomePagePath, homePage, 'utf-8');
+    const mobilePagesIndexPath = path.join(packagesDir, 'mobile/src/pages/index.ts');
+    await fs.ensureDir(path.dirname(mobilePagesIndexPath));
+    await fs.writeFile(mobilePagesIndexPath, `export { HomePage } from './HomePage';
+`, 'utf-8');
+    // admin main / App
+    const adminMainPath = path.join(packagesDir, 'admin/src/main.tsx');
+    await fs.ensureDir(path.dirname(adminMainPath));
+    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(adminMainPath, adminMain, 'utf-8');
+    const adminAppPath = path.join(packagesDir, 'admin/src/App.tsx');
+    await fs.ensureDir(path.dirname(adminAppPath));
+    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(adminAppPath, adminApp, 'utf-8');
+}

package/dist/usecases/add-api.usecase.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../core/logger.js';
+import type { Prompter } from '../core/prompts.js';
+export type AddApiInput = {
+    name?: string;
+    db: string;
+    rootDir?: string;
+    templateDir?: string;
+    dryRun: boolean;
+};
+export type AddApiDeps = {
+    logger: Logger;
+    prompter: Prompter;
+};
+export declare function createAddApiUseCase(deps: AddApiDeps): {
+    execute: (input: AddApiInput) => Promise<void>;
+};

package/dist/usecases/add-api.usecase.js

@@ -0,0 +1,87 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+import { loadProjectConfig } from '../core/project-config.js';
+import { ensurePnpmWorkspace, syncRootPackageJson, withProjectConfig, } from '../core/workspace.js';
+import { replaceScopeInDir } from '../core/template-utils.js';
+export function createAddApiUseCase(deps) {
+    const { logger, prompter } = deps;
+    async function execute(input) {
+        let { name } = input;
+        const rootDir = input.rootDir ?? process.cwd();
+        const config = await loadProjectConfig(rootDir);
+        if (!config) {
+            throw new Error('未找到 .aiko-boot.json，当前目录似乎不是脚手架根目录，请在 create 生成的根目录下执行。');
+        }
+        if (!name) {
+            name = await prompter.input('服务端名称（包名）', 'api');
+        }
+        // 计算模板根目录：
+        // - 默认使用 CLI 包内部的 templates/api-base 作为 base-api 模板；
+        // - 如果用户通过 --template-dir 显式提供：
+        //   - 若该目录本身是一个 api 根（包含 app.config.ts 和 src/），则直接使用；
+        //   - 若该目录下存在 packages/api（例如传入 scaffold 根目录），则使用 packages/api 作为模板。
+        const defaultTemplateApiDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/api-base');
+        let templateApiDir = defaultTemplateApiDir;
+        if (input.templateDir) {
+            const candidateRoot = path.resolve(input.templateDir);
+            const candidateAsApiRoot = path.join(candidateRoot, 'app.config.ts');
+            const candidateApiDir = path.join(candidateRoot, 'packages', 'api');
+            if (await fs.pathExists(candidateAsApiRoot)) {
+                // 传入的是 api 根目录（类似 api-base）
+                templateApiDir = candidateRoot;
+            }
+            else if (await fs.pathExists(path.join(candidateApiDir, 'app.config.ts'))) {
+                // 传入的是 scaffold 根目录，内部有 packages/api
+                templateApiDir = candidateApiDir;
+            }
+            else {
+                throw new Error(`无法识别的模板目录：${candidateRoot}（需要是 api 根目录，或包含 packages/api 的 scaffold 根目录）`);
+            }
+        }
+        if (input.dryRun) {
+            logger.info(`[dry-run] 将在 ${rootDir} 中新增服务端：name=${name}, db=${input.db}`);
+            logger.info(`[dry-run] 使用模板目录: ${templateApiDir}`);
+            return;
+        }
+        if (!(await fs.pathExists(templateApiDir))) {
+            throw new Error(`模板不存在：${templateApiDir}`);
+        }
+        const packagesDir = path.join(rootDir, 'packages');
+        const apiDir = path.join(packagesDir, name);
+        if (await fs.pathExists(apiDir)) {
+            throw new Error(`目标服务端目录已存在：${apiDir}`);
+        }
+        await fs.ensureDir(packagesDir);
+        await fs.copy(templateApiDir, apiDir);
+        const pkgPath = path.join(apiDir, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            const pkg = await fs.readJson(pkgPath);
+            const scope = config.scope;
+            if (scope) {
+                pkg.name = `@${scope}/${name}`;
+                await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+                await replaceScopeInDir(apiDir, 'scaffold', scope);
+            }
+            else {
+                pkg.name = name;
+                await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+            }
+        }
+        await ensurePnpmWorkspace(rootDir);
+        await withProjectConfig(rootDir, (cfg) => {
+            const apis = cfg.apis ?? [];
+            apis.push({
+                name: name,
+                path: path.join('packages', name),
+                db: input.db,
+                features: [],
+            });
+            cfg.apis = apis;
+        });
+        // 同步根 package.json（dev/build/start:api 等脚本）
+        await syncRootPackageJson(rootDir);
+        logger.info(`已在 ${apiDir} 创建服务端 "${name}"（db=${input.db}）。`);
+    }
+    return { execute };
+}

package/dist/usecases/add-app.usecase.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../core/logger.js';
+import type { Prompter } from '../core/prompts.js';
+export type AddAppInput = {
+    name?: string;
+    type?: string;
+    rootDir?: string;
+    templateDir?: string;
+    dryRun: boolean;
+};
+export type AddAppDeps = {
+    logger: Logger;
+    prompter: Prompter;
+};
+export declare function createAddAppUseCase(deps: AddAppDeps): {
+    execute: (input: AddAppInput) => Promise<void>;
+};

package/dist/usecases/add-app.usecase.js

@@ -0,0 +1,101 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+import { loadProjectConfig } from '../core/project-config.js';
+import { ensurePnpmWorkspace, syncRootPackageJson, withProjectConfig, } from '../core/workspace.js';
+import { replaceScopeInDir } from '../core/template-utils.js';
+export function createAddAppUseCase(deps) {
+    const { logger, prompter } = deps;
+    async function execute(input) {
+        let { name, type } = input;
+        const rootDir = input.rootDir ?? process.cwd();
+        const config = await loadProjectConfig(rootDir);
+        if (!config) {
+            throw new Error('未找到 .aiko-boot.json，当前目录似乎不是脚手架根目录，请在 create 生成的根目录下执行。');
+        }
+        if (!type) {
+            type = await prompter.input('应用类型（admin 或 mobile）', 'admin');
+        }
+        if (!name) {
+            name = await prompter.input('应用名称（包名）', type === 'mobile' ? 'mobile' : 'admin');
+        }
+        if (input.dryRun) {
+            logger.info(`[dry-run] 将在 ${rootDir} 中新增应用：name=${name}, type=${type}`);
+            return;
+        }
+        if (type !== 'admin' && type !== 'mobile') {
+            throw new Error('应用类型目前仅支持 admin 或 mobile');
+        }
+        // 计算模板目录：
+        // - 如果用户提供了 --template-dir，使用用户指定的（可能是 scaffold 根目录或自定义模板）
+        // - 否则，使用内置的 scaffold-default 模板
+        let templateRoot = input.templateDir;
+        if (!templateRoot) {
+            const defaultTemplateRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/scaffold-default');
+            templateRoot = defaultTemplateRoot;
+        }
+        const templateAppDir = path.join(templateRoot, 'packages', type);
+        if (!(await fs.pathExists(templateAppDir))) {
+            throw new Error(`模板不存在：${templateAppDir}`);
+        }
+        const packagesDir = path.join(rootDir, 'packages');
+        const appDir = path.join(packagesDir, name);
+        if (await fs.pathExists(appDir)) {
+            throw new Error(`目标应用目录已存在：${appDir}`);
+        }
+        // 如果还没有 core 包，则在第一次添加 admin/mobile 时一起从模板复制 core
+        const templateCoreDir = path.join(templateRoot, 'packages', 'core');
+        const coreDir = path.join(packagesDir, 'core');
+        await fs.ensureDir(packagesDir);
+        if (!(await fs.pathExists(coreDir)) && (await fs.pathExists(templateCoreDir))) {
+            await fs.copy(templateCoreDir, coreDir);
+            const corePkgPath = path.join(coreDir, 'package.json');
+            if (await fs.pathExists(corePkgPath)) {
+                const corePkg = await fs.readJson(corePkgPath);
+                const scope = config.scope;
+                if (scope) {
+                    corePkg.name = `@${scope}/core`;
+                    await fs.writeJson(corePkgPath, corePkg, { spaces: 2 });
+                    await replaceScopeInDir(coreDir, 'scaffold', scope);
+                }
+                else {
+                    corePkg.name = 'core';
+                    await fs.writeJson(corePkgPath, corePkg, { spaces: 2 });
+                }
+            }
+            logger.info(`已自动创建共享 core 包：${coreDir}`);
+        }
+        await fs.copy(templateAppDir, appDir);
+        const pkgPath = path.join(appDir, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            const pkg = await fs.readJson(pkgPath);
+            const scope = config.scope;
+            if (scope) {
+                pkg.name = `@${scope}/${name}`;
+                await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+                // 将模板中的 @scaffold/* 替换为 @<scope>/*
+                await replaceScopeInDir(appDir, 'scaffold', scope);
+            }
+            else {
+                pkg.name = name;
+                await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+            }
+        }
+        await ensurePnpmWorkspace(rootDir);
+        await withProjectConfig(rootDir, (cfg) => {
+            const apps = cfg.apps ?? [];
+            if (!name)
+                return;
+            apps.push({
+                name,
+                type: type,
+                path: path.join('packages', name),
+            });
+            cfg.apps = apps;
+        });
+        // 同步根 package.json（dev:admin / dev:mobile 等脚本）
+        await syncRootPackageJson(rootDir);
+        logger.info(`已在 ${appDir} 创建 ${type} 应用 "${name}"。`);
+    }
+    return { execute };
+}

package/dist/usecases/add-feature.usecase.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '../core/logger.js';
+import type { Prompter } from '../core/prompts.js';
+export type AddFeatureInput = {
+    serviceName: string;
+    feature: string;
+    rootDir?: string;
+    dryRun: boolean;
+};
+export type AddFeatureDeps = {
+    logger: Logger;
+    prompter: Prompter;
+};
+export declare function createAddFeatureUseCase(deps: AddFeatureDeps): {
+    execute: (input: AddFeatureInput) => Promise<void>;
+};