soloforge 1.1.2 → 1.1.30

package/dist/bin/soloforge.js

@@ -1,20 +1,28 @@
 #!/usr/bin/env node
-import fss from "node:fs";
-import path from "node:path";
-import { loadProjectConfig, getProjectKnowledgeDir, getGlobalPatternsDir } from "../knowledge/loader.js";
-import { generateHooksConfig } from "../adapters/claude_code/hooks.js";
-import { generateClaudeMd } from "../adapters/claude_code/hooks.js";
-import { generateTraeRules } from "../adapters/trae/trae_rules.js";
-import { generateTraeMcpConfig } from "../adapters/trae/trae_config.js";
-import { generateCodexMcpConfig, generateCodexHooksConfig } from "../adapters/codex/codex_config.js";
-import { generateCodexAgentsMd } from "../adapters/codex/codex_rules.js";
-import YAML from "yaml";
-const command = process.argv[2];
-const args = process.argv.slice(3);
+import { initLoggerFromEnv, userInfo } from "../engine/core/logger.js";
+import { cmdConfigResolve, cmdConfigExplain, cmdConfigConfirm, cmdConfigUnset, cmdConfigRepair, } from "./config_commands.js";
+import { command, args } from "./args.js";
+import { cmdInitAuto, cmdInitBlueprint, cmdInit } from "./commands/init.js";
+import { cmdGenerateHooks, cmdGenerateClaudeMd, cmdGenerateTrae, cmdGenerateCodex } from "./commands/hooks.js";
+import { cmdCheckWrite } from "./commands/check_write.js";
+import { cmdCheckBash, cmdPostBash } from "./commands/check_bash.js";
+import { cmdDoctor, cmdPrePrompt, cmdValidate, cmdValidateMechanisms } from "./commands/validate.js";
+import { cmdAuditTemplateMechanisms, cmdAuditDesignArtifacts, cmdUpgradeDesignArtifacts, cmdAuditTemplateVisibility, cmdAuditProjectKnowledge, } from "./commands/audit.js";
+import { cmdSyncTemplates, cmdSyncAdapters, cmdMigrate, cmdValidateReleaseGate, cmdValidateNewIssue, } from "./commands/sync.js";
+import { cmdStatus, cmdNext, cmdStage, cmdCleanup, cmdVersion } from "./commands/status.js";
 async function main() {
+    initLoggerFromEnv();
     switch (command) {
         case "init":
-            await cmdInit();
+            if (args.includes("--auto")) {
+                await cmdInitAuto();
+            }
+            else if (args.includes("--blueprint")) {
+                await cmdInitBlueprint();
+            }
+            else {
+                await cmdInit();
+            }
             break;
         case "generate-hooks":
             await cmdGenerateHooks();
@@ -22,15 +30,60 @@ async function main() {
         case "generate-claude-md":
             await cmdGenerateClaudeMd();
             break;
+        case "mcp":
+            await import("../index.js");
+            break;
         case "check-write":
             await cmdCheckWrite();
             break;
+        case "check-bash":
+            await cmdCheckBash();
+            break;
         case "post-bash":
             await cmdPostBash();
             break;
+        case "pre-prompt":
+            await cmdPrePrompt();
+            break;
         case "validate":
             await cmdValidate();
             break;
+        case "validate-mechanisms":
+            await cmdValidateMechanisms();
+            break;
+        case "audit-template-mechanisms":
+            await cmdAuditTemplateMechanisms();
+            break;
+        case "audit-design-artifacts":
+            await cmdAuditDesignArtifacts();
+            break;
+        case "upgrade-design-artifacts":
+            await cmdUpgradeDesignArtifacts();
+            break;
+        case "validate-release":
+            await cmdValidateReleaseGate();
+            break;
+        case "doctor":
+            await cmdDoctor();
+            break;
+        case "audit-template-visibility":
+            await cmdAuditTemplateVisibility();
+            break;
+        case "audit-project-knowledge":
+            await cmdAuditProjectKnowledge();
+            break;
+        case "sync-templates":
+            await cmdSyncTemplates();
+            break;
+        case "sync-adapters":
+            await cmdSyncAdapters();
+            break;
+        case "migrate":
+            await cmdMigrate();
+            break;
+        case "validate-new-issue":
+            await cmdValidateNewIssue();
+            break;
         case "generate-trae":
             await cmdGenerateTrae();
             break;
@@ -42,16 +95,49 @@ async function main() {
         case "--version":
             cmdVersion();
             break;
-        case "version":
-        case "-v":
-        case "--version":
-            cmdVersion();
+        case "config": {
+            const subCommand = args[0];
+            switch (subCommand) {
+                case "resolve":
+                    await cmdConfigResolve();
+                    break;
+                case "explain":
+                    await cmdConfigExplain();
+                    break;
+                case "confirm":
+                    await cmdConfigConfirm();
+                    break;
+                case "unset":
+                    await cmdConfigUnset();
+                    break;
+                case "repair":
+                    await cmdConfigRepair();
+                    break;
+                default:
+                    userInfo("用法: soloforge config <resolve|explain|confirm|unset|repair> [options]");
+                    userInfo("");
+                    userInfo("  resolve  解析配置字段优先级（只读，显示所有候选来源）");
+                    userInfo("  explain  解释指定字段的来源和优先级（只读，中文输出）");
+                    userInfo("  confirm  确认配置字段值（写入 config + evidence）");
+                    userInfo("  unset    移除指定字段的确认配置和 evidence");
+                    userInfo("  repair   自动修复机械类型错误并重签 evidence（支持 --dry-run/--json）");
+            }
             break;
+        }
         case "status":
             await cmdStatus();
             break;
+        case "next":
+            await cmdNext();
+            break;
+        case "stage":
+            await cmdStage();
+            break;
+        case "cleanup":
+            await cmdCleanup();
+            break;
         default:
-            console.log(`SoloForge CLI
+            userInfo(`SoloForge CLI
 
 用法: soloforge <命令>
 
@@ -60,443 +146,44 @@ async function main() {
   init --adapter trae 初始化并生成 Trae IDE 配置
   init --adapter codex 初始化并生成 Codex App 配置
   init --adapter all  同时生成所有适配器配置
+  mcp                 启动 MCP Server（供 IDE 适配器调用）
   generate-hooks      生成包含 hooks 的 .claude/settings.json
   generate-claude-md  生成包含工作流规则的 CLAUDE.md
   generate-trae       生成 .trae/mcp.json 和 .trae/rules/project_rules.md
   generate-codex      生成 .codex/ 配置和 AGENTS.md
-  check-write         PreToolUse hook，用于范围检查（读取 TOOL_INPUT 环境变量）
+  check-write         PreToolUse hook，用于范围检查（读取 stdin JSON）
+  check-bash          PreToolUse hook，阻止 Bash 直接篡改 .soloforge/state 或绕过受控任务写业务实现
+  doctor              审计 MCP 控制面、适配器 hook、状态可信和恢复路径
   post-bash           PostToolUse hook，用于跟踪 Bash 执行结果
-  validate            验证 .soloforge/config.yaml 和知识文件
+  validate            验证项目配置和知识文件（config.yaml 可选，缺失时自动推断）
+  validate-mechanisms 验证双层机制承载模型完整性（模板层 + 机制层）
+  audit-template-mechanisms 扫描模板与机制注册表交叉校验（--json 输出完整报告，--changed-only 仅检查变更文件）
+  audit-design-artifacts 审计架构/数据库/API 设计产物包（只读，--json 输出报告）
+  audit-project-knowledge 审计用户项目 .soloforge/knowledge 自定义规则承载与消费
+  upgrade-design-artifacts 生成存量设计资产升级计划（默认 dry-run，--apply --confirm 仅建立已归档迁移基线）
+  validate-release    验证发布门禁（契约、场景矩阵、消费 trace、双层机制、回归基线）
+  sync-templates      同步模板到项目（默认 dry-run，--apply 需 --confirm）
+  sync-adapters       同步适配器 Prompt（默认 dry-run，--apply 需 --confirm）
+  migrate             迁移项目 .soloforge/（默认 dry-run，--apply 需确认）
   version             显示 SoloForge 版本信息
-  status              显示当前项目的 SoloForge 状态
+  config resolve       解析配置字段优先级（只读）
+  config explain        解释配置字段来源（只读，中文）
+  config confirm <field> <value>  确认配置字段（写入 config + evidence）
+  config repair                   自动修复机械类型错误并重签 evidence
+  config unset <field>  移除确认配置
+  status                显示当前项目的 SoloForge 状态
+  next                  查询下一步操作和可执行工作包（默认只读）
+  next --json           纯 JSON 输出（无日志污染）
+  next --write-snapshot 将导航快照写入 .soloforge/navigation-snapshot.json
+  stage                 显示当前项目阶段和任务阶段
+  stage --explain       详细解释当前阶段（判断依据、必要条件、下一阶段）
+  cleanup               清理过期任务和 evidence（默认 dry-run，--apply 执行实际清理）
+  cleanup --stale       检测陈旧 current-task 指针（--apply 时受控归档）
 `);
     }
 }
-async function cmdInit() {
-    const interactive = args.includes("--interactive");
-    const adapter = getArgValue("--adapter") || "claude-code";
-    const projectPath = process.cwd();
-    // 创建目录
-    const dirs = [
-        ".soloforge/state",
-        ".soloforge/state/debt",
-        ".soloforge/knowledge/patterns",
-        ".soloforge/knowledge/procedures",
-        ".soloforge/knowledge/domain/backend",
-        ".soloforge/knowledge/domain/frontend",
-        ".soloforge/knowledge/acceptance_templates",
-        ".soloforge/knowledge/review_rules",
-        ".soloforge/knowledge/product_profiles",
-        ".soloforge/staged",
-    ];
-    for (const dir of dirs) {
-        fss.mkdirSync(path.join(projectPath, dir), { recursive: true });
-    }
-    // 若不存在则生成 config.yaml
-    const configPath = path.join(projectPath, ".soloforge", "config.yaml");
-    if (!fss.existsSync(configPath) || interactive) {
-        const config = interactive ? await interactiveConfig() : defaultConfig(projectPath);
-        fss.writeFileSync(configPath, YAML.stringify(config), "utf-8");
-        console.log("✅ .soloforge/config.yaml created");
-    }
-    // 生成 .mcp.json（SoloForge + Playwright + Figma）
-    if (adapter === "claude-code" || adapter === "all") {
-        const mcpPath = path.join(projectPath, ".mcp.json");
-        if (!fss.existsSync(mcpPath)) {
-            const soloforgeDist = path.resolve(import.meta.dirname, "..");
-            const mcpConfig = {
-                mcpServers: {
-                    soloforge: {
-                        command: "node",
-                        args: [path.join(soloforgeDist, "index.js")],
-                        env: { SOLOFORGE_PROJECT: projectPath },
-                    },
-                    playwright: {
-                        command: "npx",
-                        args: ["@playwright/mcp@latest", "--headless"],
-                    },
-                    figma: {
-                        type: "http",
-                        url: "https://mcp.figma.com/mcp",
-                    },
-                },
-            };
-            fss.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-            console.log("✅ .mcp.json created (soloforge + playwright + figma)");
-            console.log("💡 提示: 建议将 .mcp.json 加入 .gitignore（含本地绝对路径）");
-        }
-        // 生成 hooks
-        await cmdGenerateHooks();
-        // 生成 CLAUDE.md
-        await cmdGenerateClaudeMdInner(projectPath);
-    }
-    // 生成 Trae IDE 配置
-    if (adapter === "trae" || adapter === "all") {
-        await cmdGenerateTraeInner(projectPath);
-        console.log("💡 提示: 使用项目级 .trae/ 配置需在 Trae 中开启 beta flag");
-    }
-    // 生成 Codex App 配置
-    if (adapter === "codex" || adapter === "all") {
-        await cmdGenerateCodexInner(projectPath);
-    }
-    // 复制默认全局模式
-    const globalDir = getGlobalPatternsDir();
-    fss.mkdirSync(globalDir, { recursive: true });
-    const templatesDir = path.resolve(import.meta.dirname, "..", "..", "templates", "patterns");
-    if (fss.existsSync(templatesDir)) {
-        const files = fss.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
-        for (const f of files) {
-            const src = path.join(templatesDir, f);
-            const dest = path.join(globalDir, f);
-            if (!fss.existsSync(dest)) {
-                fss.copyFileSync(src, dest);
-            }
-        }
-        console.log(`✅ ${files.length} default patterns copied to ~/.soloforge/patterns/`);
-    }
-    // 复制项目层知识模板（procedures/domain/product_profiles）
-    const knowledgeTemplatesDir = path.resolve(import.meta.dirname, "..", "..", "templates", "knowledge");
-    if (fss.existsSync(knowledgeTemplatesDir)) {
-        const subDirs = ["procedures", "domain", "product_profiles", "acceptance_templates", "review_rules"];
-        let copiedCount = 0;
-        for (const subDir of subDirs) {
-            const srcDir = path.join(knowledgeTemplatesDir, subDir);
-            if (!fss.existsSync(srcDir))
-                continue;
-            const destDir = path.join(projectPath, ".soloforge", "knowledge", subDir);
-            fss.mkdirSync(destDir, { recursive: true });
-            const files = fss.readdirSync(srcDir).filter((f) => f.endsWith(".md") || f.endsWith(".yaml") || f.endsWith(".yml"));
-            for (const f of files) {
-                const src = path.join(srcDir, f);
-                const dest = path.join(destDir, f);
-                if (!fss.existsSync(dest)) {
-                    fss.copyFileSync(src, dest);
-                    copiedCount++;
-                }
-            }
-        }
-        if (copiedCount > 0) {
-            console.log(`✅ ${copiedCount} knowledge templates copied to .soloforge/knowledge/`);
-        }
-    }
-    // 确保 .gitignore 包含必要条目
-    ensureGitignore(projectPath);
-    console.log(`\n✅ SoloForge 初始化完成 (适配器: ${adapter})。${adapter === "trae" ? "请打开 Trae IDE 开始使用。" :
-        adapter === "codex" ? "请打开 Codex App 开始使用。" :
-            adapter === "all" ? "可在 Claude Code、Trae IDE 或 Codex App 中使用。" :
-                "请打开 Claude Code 开始使用。"}`);
-}
-function ensureGitignore(projectPath) {
-    const gitignorePath = path.join(projectPath, ".gitignore");
-    const requiredEntries = [".mcp.json", ".soloforge/"];
-    let content = "";
-    if (fss.existsSync(gitignorePath)) {
-        content = fss.readFileSync(gitignorePath, "utf-8");
-    }
-    const lines = content.split("\n");
-    const missing = requiredEntries.filter((entry) => !lines.some((l) => l.trim() === entry));
-    if (missing.length > 0) {
-        const addition = (content.endsWith("\n") ? "" : "\n") + missing.join("\n") + "\n";
-        fss.appendFileSync(gitignorePath, addition, "utf-8");
-        console.log(`✅ .gitignore updated with: ${missing.join(", ")}`);
-    }
-}
-async function cmdGenerateHooks() {
-    const projectPath = process.cwd();
-    const soloforgeDist = path.resolve(import.meta.dirname, "..");
-    const hooksConfig = generateHooksConfig(path.join(soloforgeDist, "bin", "soloforge.js"));
-    const claudeDir = path.join(projectPath, ".claude");
-    fss.mkdirSync(claudeDir, { recursive: true });
-    const settingsPath = path.join(claudeDir, "settings.json");
-    let existing = {};
-    if (fss.existsSync(settingsPath)) {
-        try {
-            existing = JSON.parse(fss.readFileSync(settingsPath, "utf-8"));
-        }
-        catch {
-            existing = {};
-        }
-    }
-    // 仅 merge hooks 字段，保留用户的 permissions/env 等设置
-    existing.hooks = hooksConfig.hooks;
-    fss.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf-8");
-    console.log("✅ .claude/settings.json updated with hooks");
-}
-async function cmdGenerateClaudeMd() {
-    await cmdGenerateClaudeMdInner(process.cwd());
-}
-async function cmdGenerateTrae() {
-    await cmdGenerateTraeInner(process.cwd());
-}
-async function cmdGenerateCodex() {
-    await cmdGenerateCodexInner(process.cwd());
-}
-async function cmdGenerateCodexInner(projectPath) {
-    const soloforgeDist = path.resolve(import.meta.dirname, "..");
-    // 生成 .codex/config.toml
-    const codexDir = path.join(projectPath, ".codex");
-    fss.mkdirSync(codexDir, { recursive: true });
-    const tomlContent = generateCodexMcpConfig(path.join(soloforgeDist, "index.js"), projectPath);
-    fss.writeFileSync(path.join(codexDir, "config.toml"), tomlContent, "utf-8");
-    console.log("✅ .codex/config.toml created");
-    // 生成 .codex/hooks.json
-    const hooksContent = generateCodexHooksConfig(path.join(soloforgeDist, "bin", "soloforge.js"));
-    fss.writeFileSync(path.join(codexDir, "hooks.json"), hooksContent, "utf-8");
-    console.log("✅ .codex/hooks.json created");
-    // 生成 AGENTS.md
-    const config = await loadProjectConfig(projectPath);
-    const agentsContent = generateCodexAgentsMd(config);
-    fss.writeFileSync(path.join(projectPath, "AGENTS.md"), agentsContent, "utf-8");
-    console.log("✅ AGENTS.md created");
-}
-async function cmdGenerateTraeInner(projectPath) {
-    // 生成 .trae/mcp.json
-    const traeDir = path.join(projectPath, ".trae");
-    fss.mkdirSync(traeDir, { recursive: true });
-    const traeMcpPath = path.join(traeDir, "mcp.json");
-    const traeMcpConfig = generateTraeMcpConfig();
-    fss.writeFileSync(traeMcpPath, JSON.stringify(traeMcpConfig, null, 2), "utf-8");
-    console.log("✅ .trae/mcp.json created");
-    // 生成 .trae/rules/project_rules.md
-    const rulesDir = path.join(traeDir, "rules");
-    fss.mkdirSync(rulesDir, { recursive: true });
-    const config = await loadProjectConfig(projectPath);
-    const rulesContent = generateTraeRules(config);
-    fss.writeFileSync(path.join(rulesDir, "project_rules.md"), rulesContent, "utf-8");
-    console.log("✅ .trae/rules/project_rules.md created");
-}
-async function cmdGenerateClaudeMdInner(projectPath) {
-    const config = await loadProjectConfig(projectPath);
-    const content = generateClaudeMd(config);
-    fss.writeFileSync(path.join(projectPath, "CLAUDE.md"), content, "utf-8");
-    console.log("✅ CLAUDE.md created");
-}
-async function cmdCheckWrite() {
-    try {
-        // 检测运行环境: Claude Code 通过 TOOL_INPUT 环境变量，Codex 通过 stdin JSON
-        const isClaudeCode = !!process.env.TOOL_INPUT;
-        let toolInput;
-        if (isClaudeCode) {
-            toolInput = process.env.TOOL_INPUT;
-        }
-        else {
-            // Codex: 从 stdin 读取 JSON
-            const chunks = [];
-            for await (const chunk of process.stdin) {
-                chunks.push(chunk);
-            }
-            const stdin = Buffer.concat(chunks).toString().trim();
-            if (stdin)
-                toolInput = stdin;
-        }
-        // 回退: 从命令行参数读取
-        if (!toolInput) {
-            toolInput = args[0];
-        }
-        if (!toolInput) {
-            process.exit(0); // 无输入，放行
-        }
-        const parsed = JSON.parse(toolInput);
-        let filePath;
-        let content;
-        if (isClaudeCode) {
-            filePath = parsed.file_path || parsed.path || "";
-            content = parsed.content || parsed.new_string || "";
-        }
-        else {
-            // Codex stdin JSON 使用不同的字段名
-            const input = parsed.input || parsed;
-            filePath = input.file_path || input.path || "";
-            content = input.content || input.new_string || "";
-        }
-        // 加载配置
-        const projectPath = resolveProjectPath();
-        const config = await loadProjectConfig(projectPath);
-        // 从配置中收集所有允许路径
-        const allowedPaths = [
-            ...(config.scope.backend || []),
-            ...(config.scope.frontend || []),
-            ...config.repos.flatMap((r) => r.scope || []),
-        ].map((p) => path.resolve(projectPath, p));
-        // 使用 scope_controller 统一检查
-        const { checkScope } = await import("../engine/scope_controller.js");
-        const result = checkScope(filePath, allowedPaths, content || undefined);
-        if (result.severity === "blocked") {
-            if (isClaudeCode) {
-                console.error(JSON.stringify(result));
-                process.exit(1);
-            }
-            else {
-                // Codex: stdout 输出特定 JSON 拒绝格式
-                const denyOutput = {
-                    hookSpecificOutput: {
-                        hookEventName: "PreToolUse",
-                        permissionDecision: "deny",
-                        permissionDecisionReason: result.reason || "Write blocked by scope check",
-                    },
-                };
-                process.stdout.write(JSON.stringify(denyOutput));
-                process.exit(0);
-            }
-        }
-        if (result.severity === "warning") {
-            if (isClaudeCode) {
-                console.error(JSON.stringify(result));
-            }
-            // 警告不阻止操作
-        }
-        process.exit(0); // 允许
-    }
-    catch (e) {
-        console.error(`SoloForge check-write error: ${e instanceof Error ? e.message : String(e)}`);
-        process.exit(0); // 出错时放行（hooks 的 fail-open 策略）
-    }
-}
-function resolveProjectPath() {
-    const envPath = process.env.SOLOFORGE_PROJECT;
-    if (envPath) {
-        try {
-            const stat = fss.statSync(envPath);
-            if (!stat.isDirectory()) {
-                console.error(`⚠️  SOLOFORGE_PROJECT (${envPath}) 不是目录，回退到 cwd`);
-                return process.cwd();
-            }
-            return envPath;
-        }
-        catch {
-            console.error(`⚠️  SOLOFORGE_PROJECT (${envPath}) 路径不存在，回退到 cwd`);
-            return process.cwd();
-        }
-    }
-    return process.cwd();
-}
-async function cmdPostBash() {
-    // Bash 的 PostToolUse hook — 目前为空操作占位符
-    // 未来: 跟踪命令结果，检测构建/测试失败
-    process.exit(0);
-}
-async function cmdValidate() {
-    const projectPath = process.cwd();
-    const configPath = path.join(projectPath, ".soloforge", "config.yaml");
-    if (!fss.existsSync(configPath)) {
-        console.error("❌ 未找到 .soloforge/config.yaml，请先运行 'soloforge init'。");
-        process.exit(1);
-    }
-    try {
-        const config = await loadProjectConfig(projectPath);
-        console.log("✅ config.yaml is valid");
-        // 检查知识文件
-        const knowledgeDir = getProjectKnowledgeDir(config);
-        if (fss.existsSync(knowledgeDir)) {
-            const { KnowledgeIndexManager } = await import("../knowledge/index_manager.js");
-            const index = new KnowledgeIndexManager(config);
-            await index.build();
-            const entries = index.getAllEntries();
-            console.log(`✅ ${entries.project.length} project knowledge entries indexed`);
-            const issues = await index.checkHealth();
-            if (issues.length > 0) {
-                console.log(`⚠️  ${issues.length} health issues found:`);
-                for (const { entry, issue } of issues) {
-                    console.log(`  - ${entry.name}: ${issue}`);
-                }
-            }
-        }
-    }
-    catch (e) {
-        console.error(`❌ 验证失败: ${e.message}`);
-        process.exit(1);
-    }
-}
-async function cmdStatus() {
-    const projectPath = process.cwd();
-    console.log(`SoloForge 状态: ${projectPath}`);
-    const config = await loadProjectConfig(projectPath);
-    console.log(`  产品: ${config.product_profile}`);
-    console.log(`  后端: ${config.tech_stack.backend.framework || "未配置"}`);
-    console.log(`  前端: ${config.tech_stack.frontend.framework || "未配置"}`);
-    const knowledgeDir = getProjectKnowledgeDir(config);
-    if (fss.existsSync(knowledgeDir)) {
-        const { KnowledgeIndexManager } = await import("../knowledge/index_manager.js");
-        const index = new KnowledgeIndexManager(config);
-        await index.build();
-        const entries = index.getAllEntries();
-        console.log(`  知识: ${entries.global.length} 全局 + ${entries.project.length} 项目`);
-    }
-    else {
-        console.log("  知识: 未初始化");
-    }
-}
-function defaultConfig(projectPath) {
-    const backendLang = process.env.SOLOFORGE_BACKEND_LANG || "java";
-    const backendFramework = process.env.SOLOFORGE_BACKEND_FRAMEWORK || "spring-boot";
-    const frontendLang = process.env.SOLOFORGE_FRONTEND_LANG || "typescript";
-    const frontendFramework = process.env.SOLOFORGE_FRONTEND_FRAMEWORK || "react";
-    return {
-        schema_version: 1,
-        name: path.basename(projectPath),
-        tech_stack: {
-            backend: { lang: backendLang, framework: backendFramework, version: "3.x" },
-            frontend: { lang: frontendLang, framework: frontendFramework, version: "18" },
-        },
-        product_profile: "default",
-        repos: [
-            { name: "backend", path: "./backend", lang: backendLang, framework: backendFramework, scope: ["src/main/java", "src/test/java"] },
-            { name: "frontend", path: "./frontend", lang: frontendLang, framework: frontendFramework, scope: ["src"] },
-        ],
-        build_commands: {
-            backend: { build: "cd backend && mvn compile -q", test: "cd backend && mvn test", full: "cd backend && mvn verify" },
-            frontend: { build: "cd frontend && npm run build", test: "cd frontend && npm test", full: "cd frontend && npm run build && npm test" },
-        },
-        scope: {
-            backend: ["backend/src"],
-            frontend: ["frontend/src"],
-        },
-    };
-}
-async function interactiveConfig() {
-    const readline = await import("node:readline");
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (q) => new Promise((res) => rl.question(q, res));
-    const name = await ask("项目名称: ") || "my-project";
-    const product = await ask("产品类型 (saas/b2b-internal/b2c): ") || "default";
-    const backendFramework = await ask("后端框架 (spring-boot): ") || "spring-boot";
-    const frontendFramework = await ask("前端框架 (react): ") || "react";
-    rl.close();
-    return {
-        schema_version: 1,
-        name,
-        product_profile: product,
-        tech_stack: {
-            backend: { lang: "java", framework: backendFramework, version: "" },
-            frontend: { lang: "typescript", framework: frontendFramework, version: "" },
-        },
-        repos: [],
-        build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } },
-        scope: { backend: [], frontend: [] },
-    };
-}
-function cmdVersion() {
-    // dist/bin/soloforge.js → dist/package.json (local) 或 package.json (global npm)
-    const pkgPath = path.resolve(import.meta.dirname, "..", "package.json");
-    try {
-        const pkg = JSON.parse(fss.readFileSync(pkgPath, "utf-8"));
-        console.log("SoloForge v" + pkg.version);
-    }
-    catch {
-        // 回退: 从 dist 同级目录查找
-        const altPath = path.resolve(import.meta.dirname, "..", "..", "package.json");
-        const pkg = JSON.parse(fss.readFileSync(altPath, "utf-8"));
-        console.log("SoloForge v" + pkg.version);
-    }
-}
-main().catch((e) => { console.error(e); process.exit(1); });
-function getArgValue(flag) {
-    const idx = args.indexOf(flag);
-    if (idx === -1 || idx + 1 >= args.length)
-        return undefined;
-    const result = args[idx + 1];
-    if (result.startsWith("--"))
-        return undefined;
-    return result;
-}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});
 //# sourceMappingURL=soloforge.js.map