vibe-arch 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,269 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const inquirer = __importStar(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const analyzer_1 = require("../analyzer");
+const generator_1 = require("../generator");
+async function initCommand(targetDir, options = {}) {
+    const rootDir = path.resolve(targetDir);
+    const isNonInteractive = !!(options.yes || !process.stdin.isTTY);
+    console.log(chalk_1.default.blue(`\n[vibe-arch] Analyzing Project: ${rootDir}\n`));
+    const context = (0, analyzer_1.getProjectContext)(rootDir);
+    let selectedArchitecture;
+    if (!isNonInteractive) {
+        // 아키텍처 선택 옵션
+        const { archChoice } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "archChoice",
+                message: "How would you like to define the architecture pattern?",
+                choices: [
+                    {
+                        name: "🤖 Let AI recommend (requires OPENAI_API_KEY)",
+                        value: "ai",
+                    },
+                    { name: "📋 Choose manually", value: "manual" },
+                ],
+            },
+        ]);
+        if (archChoice === "ai") {
+            console.log(chalk_1.default.blue("\n[vibe-arch] Calling AI for architecture recommendation...\n"));
+            const recommendation = await (0, analyzer_1.getAiArchitectureRecommendation)(context);
+            if (recommendation) {
+                console.log(chalk_1.default.green(`✅ AI recommends: ${chalk_1.default.bold(recommendation)}\n`));
+                const { confirmArch } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmArch",
+                        message: `Use ${recommendation} architecture?`,
+                        default: true,
+                    },
+                ]);
+                if (confirmArch) {
+                    selectedArchitecture = recommendation;
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow("\n[INFO] Could not get AI recommendation. Falling back to manual selection...\n"));
+            }
+        }
+        // AI 실패 시 또는 수동 선택 시
+        if (!selectedArchitecture) {
+            const { architecture } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "architecture",
+                    message: "Select the architecture pattern:",
+                    choices: [
+                        { name: "🔷 Hexagonal (Ports & Adapters)", value: "hexagonal" },
+                        { name: "🧹 Clean Architecture", value: "clean" },
+                        { name: "🎬 MVC (Model-View-Controller)", value: "mvc" },
+                        { name: "📚 Layered (3-tier)", value: "layered" },
+                        { name: "🧩 Modular (Feature-based)", value: "modular" },
+                    ],
+                    default: "layered",
+                },
+            ]);
+            selectedArchitecture = architecture;
+        }
+    }
+    else {
+        // 비대화형 모드: --arch 플래그가 있으면 사용, 없으면 AI 추천 시도
+        if (options.arch) {
+            selectedArchitecture = options.arch;
+        }
+        else {
+            console.log(chalk_1.default.blue("[vibe-arch] Analyzing project for optimal architecture..."));
+            const recommendation = await (0, analyzer_1.getAiArchitectureRecommendation)(context);
+            if (recommendation) {
+                selectedArchitecture = recommendation;
+                console.log(chalk_1.default.green(`[vibe-arch] Selected: ${recommendation}\n`));
+            }
+            else {
+                // AI 실패 시 지능형 기본값 선택
+                selectedArchitecture = getSmartDefaultArchitecture(context);
+                console.log(chalk_1.default.green(`[vibe-arch] Selected: ${selectedArchitecture}\n`));
+            }
+        }
+    }
+    let injectionMode = "inline";
+    if (!isNonInteractive) {
+        const { mode } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "mode",
+                message: "Where should architecture metadata be stored?",
+                choices: [
+                    {
+                        name: "📝 Inline (at the top of each source file)",
+                        value: "inline",
+                    },
+                    {
+                        name: "📁 Sidecar (mirroring structure in /arch directory)",
+                        value: "sidecar",
+                    },
+                    { name: "🚫 Disabled (no per-file metadata)", value: "disabled" },
+                ],
+                default: "inline",
+            },
+        ]);
+        injectionMode = mode;
+    }
+    else if (options.injection) {
+        // 비대화형 모드에서 --injection 옵션이 있으면 사용
+        const valid = ["inline", "sidecar", "disabled"];
+        if (valid.includes(options.injection)) {
+            injectionMode = options.injection;
+        }
+        else {
+            console.log(chalk_1.default.yellow(`[WARN] Invalid injection mode: ${options.injection}. Using default: inline\n`));
+        }
+    }
+    const spec = {
+        architecture: selectedArchitecture,
+        language: options.lang || context.language || "typescript",
+        root: rootDir,
+        bounded_contexts: [],
+        layers: getDefaultLayers(selectedArchitecture),
+        comment_injection: injectionMode,
+        ai_targets: ["CLAUDE.md", "GEMINI.md", "AI.md"],
+    };
+    saveSpec(rootDir, spec);
+    console.log(chalk_1.default.green(`\n✅ [SUCCESS] Initialized with ${chalk_1.default.bold(selectedArchitecture)} architecture!`));
+}
+function saveSpec(rootDir, spec) {
+    const specJsonPath = path.join(rootDir, ".arch-spec.json");
+    const specYamlPath = path.join(rootDir, ".arch-spec.yaml");
+    fs.writeFileSync(specJsonPath, JSON.stringify(spec, null, 2), "utf-8");
+    fs.writeFileSync(specYamlPath, (0, generator_1.generateArchSpec)(spec), "utf-8");
+    (0, generator_1.updateAiContexts)(rootDir, spec);
+}
+function getDefaultLayers(architecture) {
+    const templates = {
+        hexagonal: {
+            core: {
+                patterns: ["domain", "port", "model", "entity"],
+                forbidden_deps: ["application", "infrastructure"],
+                allowed_deps: [],
+            },
+            application: {
+                patterns: ["service", "usecase", "handler", "command", "query"],
+                forbidden_deps: ["infrastructure"],
+                allowed_deps: ["core"],
+            },
+            infrastructure: {
+                patterns: [
+                    "adapter",
+                    "config",
+                    "repository",
+                    "persistence",
+                    "web",
+                    "external",
+                ],
+                forbidden_deps: [],
+                allowed_deps: ["core", "application"],
+            },
+        },
+        modular: {
+            app: {
+                patterns: ["app", "index", "main"],
+                forbidden_deps: [],
+                allowed_deps: ["module", "shared"],
+            },
+            module: {
+                patterns: ["feature", "module"],
+                forbidden_deps: ["app"],
+                allowed_deps: ["shared", "module"],
+            },
+            shared: {
+                patterns: ["shared", "common", "types"],
+                forbidden_deps: ["app", "module"],
+                allowed_deps: [],
+            },
+        },
+        layered: {
+            presentation: {
+                patterns: ["controller", "ui"],
+                forbidden_deps: ["persistence"],
+                allowed_deps: ["business"],
+            },
+            business: {
+                patterns: ["service", "logic"],
+                forbidden_deps: [],
+                allowed_deps: ["persistence"],
+            },
+            persistence: {
+                patterns: ["repository", "dao"],
+                forbidden_deps: ["presentation"],
+                allowed_deps: [],
+            },
+        },
+    };
+    return templates[architecture] || templates["layered"];
+}
+/**
+ * 프로젝트 구조를 분석하여 최적의 아키텍처를 추천합니다 (AI 없을 때 사용).
+ */
+function getSmartDefaultArchitecture(context) {
+    const deps = context.packageJson?.dependencies || {};
+    const tree = context.tree.map((p) => p.toLowerCase());
+    // React/Vue 감지 (프론트엔드 = modular)
+    if (deps.react || deps.vue || deps.svelte || deps.angular) {
+        return "modular";
+    }
+    // Express/Fastify/Spring 감지 (백엔드 = layered)
+    if (deps.express || deps.fastify || deps.koa || deps.spring) {
+        return "layered";
+    }
+    // 마이크로서비스 구조 감지 (여러 도메인 폴더 = hexagonal)
+    const domainFolders = tree.filter((p) => p.includes("/src/") &&
+        ["api", "domain", "service", "adapter", "port"].some((keyword) => p.includes(keyword)));
+    if (domainFolders.length > 5) {
+        return "hexagonal";
+    }
+    // feature/ module/ 폴더 감지 (feature-based = modular)
+    if (tree.some((p) => p.includes("feature/") || p.includes("module/"))) {
+        return "modular";
+    }
+    // 기본값: layered
+    return "layered";
+}

package/dist/commands/validate.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const validator_1 = require("../analyzer/validator");
+async function validateCommand(targetDir) {
+    const rootDir = path.resolve(targetDir);
+    const specPath = path.join(rootDir, '.arch-spec.json');
+    if (!fs.existsSync(specPath)) {
+        console.error(chalk_1.default.red('\n[ERROR] .arch-spec.json not found. Run: vibe-arch init\n'));
+        process.exit(1);
+    }
+    try {
+        const spec = JSON.parse(fs.readFileSync(specPath, 'utf-8'));
+        console.log(chalk_1.default.blue(`\n🔍 Scanning architecture violations... (${spec.architecture})\n`));
+        const violations = (0, validator_1.validateProject)(rootDir, spec);
+        if (violations.length === 0) {
+            console.log(chalk_1.default.green('✅ No violations found. Project is clean!\n'));
+            return;
+        }
+        // 레이어별 그룹화
+        const byLayer = {};
+        for (const v of violations) {
+            if (!byLayer[v.from])
+                byLayer[v.from] = [];
+            byLayer[v.from].push(v);
+        }
+        for (const [layer, vs] of Object.entries(byLayer)) {
+            console.log(chalk_1.default.yellow(`⚠️  Layer '${layer}': ${vs.length} violation(s)`));
+            for (const v of vs) {
+                const relPath = path.relative(rootDir, v.filePath);
+                console.log(`   - ${chalk_1.default.gray(relPath)}`);
+                console.log(`     ${chalk_1.default.red(v.message)}`);
+            }
+            console.log('');
+        }
+        console.log(chalk_1.default.bold.red(`Total ${violations.length} violation(s) detected.\n`));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`[ERROR] Failed to validate: ${err.message}`));
+    }
+}