atabey 0.0.6 → 0.0.8

package/{src/cli/commands/init/scaffold-core.ts → framework-mcp/dist/src/cli/commands/init/scaffold-core.js}

@@ -1,30 +1,22 @@
 import fs from "fs";
 import path from "path";
-import { 
-    remapFrameworkContent, 
-    type AdapterConfig, 
-    type AdapterId,
-    ADAPTERS
-} from "../../adapters/index.js";
+import { remapFrameworkContent, ADAPTERS } from "../../adapters/index.js";
 import { SHIM_TEMPLATES } from "../../shims.js";
 import { writeJsonFile, writeTextFile } from "../../utils/fs.js";
 import { getPackageRoot, getPackageVersion } from "../../utils/pkg.js";
 import { ALL_AGENTS } from "../../../modules/agents/definitions.js";
-
-import { TRANSLATIONS, type SupportedLanguage } from "../../utils/i18n.js";
-
+import { TRANSLATIONS } from "../../utils/i18n.js";
 const FRAMEWORK_NAME = "Agent Atabey";
-
 const COLOR_PALETTES = {
     "Modern Blue": { primary: "#0ea5e9", secondary: "#64748b", accent: "#f43f5e" },
     "Enterprise Slate": { primary: "#334155", secondary: "#94a3b8", accent: "#10b981" },
     "Deep Purple": { primary: "#8b5cf6", secondary: "#d8b4fe", accent: "#f59e0b" }
 };
-
-export function scaffoldConstitution(targetDir: string, frameworkDir: string, adapterId: AdapterId, dryRun: boolean, language: SupportedLanguage = "tr") {
-    if (dryRun) return;
+export function scaffoldConstitution(targetDir, frameworkDir, adapterId, dryRun, language = "tr") {
+    if (dryRun)
+        return;
     const t = TRANSLATIONS[language];
-    let content = `# 🎖️ ${t.constitution_title}\n\nDiscipline and Order.`;
+    let content = `# [ATABEY] ${t.constitution_title}\n\nDiscipline and Order.`;
     let readSuccess = false;
     try {
         const templatePath = path.join(getPackageRoot(), "ATABEY.md");
@@ -32,36 +24,29 @@ export function scaffoldConstitution(targetDir: string, frameworkDir: string, ad
             content = fs.readFileSync(templatePath, "utf8");
             readSuccess = true;
         }
-    } catch (e) {
-        console.warn(`⚠️  Failed to read global constitution template: ${e}`);
+    }
+    catch (e) {
+        console.warn(`[WARN]  Failed to read global constitution template: ${e}`);
     }
     content = remapFrameworkContent(content, frameworkDir, adapterId);
     const destPath = path.join(targetDir, frameworkDir, "ATABEY.md");
     writeTextFile(destPath, content);
-
-    console.warn(`✅ Constitution file created inside: ${frameworkDir}/ATABEY.md${readSuccess ? "" : " (default template)"}`);
+    console.warn(`[OK] Constitution file created inside: ${frameworkDir}/ATABEY.md${readSuccess ? "" : " (default template)"}`);
 }
-
-export function scaffoldFrameworkConfigs(
-    targetDir: string, 
-    fDir: string, 
-    adapter: AdapterConfig, 
-    dryRun: boolean, 
-    selectedPalette: string,
-    options?: { unified?: boolean; adapters?: string[]; backendLanguage?: string; language?: SupportedLanguage }
-) {
-    if (dryRun) return;
+export function scaffoldFrameworkConfigs(targetDir, fDir, adapter, dryRun, selectedPalette, options) {
+    if (dryRun)
+        return;
     const frameworkDir = path.join(targetDir, fDir);
-    const palette = COLOR_PALETTES[selectedPalette as keyof typeof COLOR_PALETTES] || COLOR_PALETTES["Modern Blue"];
+    const palette = COLOR_PALETTES[selectedPalette] || COLOR_PALETTES["Modern Blue"];
     const language = options?.language || "tr";
     const t = TRANSLATIONS[language];
-
     const config = {
         name: FRAMEWORK_NAME,
         version: getPackageVersion(),
         unified: options?.unified || false,
         adapters: options?.adapters || [adapter.id],
         backendLanguage: options?.backendLanguage || "Node.js (TypeScript)",
+        frontendFramework: options?.frontendFramework || "Vite (React)",
         language: language,
         theme: {
             palette: selectedPalette,
@@ -69,67 +54,58 @@ export function scaffoldFrameworkConfigs(
         }
     };
     writeJsonFile(path.join(frameworkDir, "config.json"), config, dryRun);
-
     // Scaffold shared-facts.json in memory-graph
     const graphDir = path.join(frameworkDir, "memory-graph");
-    if (!fs.existsSync(graphDir)) fs.mkdirSync(graphDir, { recursive: true });
+    if (!fs.existsSync(graphDir))
+        fs.mkdirSync(graphDir, { recursive: true });
     const sharedFactsPath = path.join(graphDir, "shared-facts.json");
     if (!fs.existsSync(sharedFactsPath)) {
         writeJsonFile(sharedFactsPath, {
             project: FRAMEWORK_NAME,
             initializedAt: new Date().toISOString(),
-            stack: [options?.backendLanguage || "Node.js (TypeScript)"],
+            stack: [
+                options?.backendLanguage || "Node.js (TypeScript)",
+                options?.frontendFramework || "Vite (React)"
+            ],
             language: language,
             policies: []
         }, dryRun);
     }
-
-    let statusContent = `# 🎖️ ${t.status_title}\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n`;
-    
+    let statusContent = `# [ATABEY] ${t.status_title}\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n`;
     const activeAgents = ALL_AGENTS;
-
-    const initialStatusJson: Record<string, { state: string; task: string; lastUpdated: string }> = {};
+    const initialStatusJson = {};
     const now = new Date().toISOString();
-
     for (const ag of activeAgents) {
         statusContent += "| @" + ag.name + " | " + t.agent_ready + " | Idle | - | - | - | - |\n";
         initialStatusJson[ag.name] = { state: "READY", task: "Idle", lastUpdated: now };
     }
     writeTextFile(path.join(frameworkDir, "STATUS.md"), statusContent);
-
     // Populate initial status.json
     const statusJsonPath = path.join(frameworkDir, "memory", "status.json");
-    if (!fs.existsSync(path.join(frameworkDir, "memory"))) fs.mkdirSync(path.join(frameworkDir, "memory"), { recursive: true });
+    if (!fs.existsSync(path.join(frameworkDir, "memory")))
+        fs.mkdirSync(path.join(frameworkDir, "memory"), { recursive: true });
     writeJsonFile(statusJsonPath, initialStatusJson, dryRun);
 }
-
-export function scaffoldShims(
-    projectRoot: string, 
-    coreDir: string, 
-    adapterId: AdapterId, 
-    adapter: AdapterConfig, 
-    dryRun: boolean,
-    unified: boolean = false
-) {
+export function scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun, unified = false) {
     for (const [name, content] of Object.entries(SHIM_TEMPLATES)) {
         // Normalize: "antigravity-cli" template key needs exact match or prefix match
         const isSelectedAdapter = name === adapterId ||
             name.toLowerCase() === adapterId.split("-")[0].toLowerCase();
-        
         if (unified || isSelectedAdapter) {
             const shimContent = remapFrameworkContent(content, coreDir, adapterId);
             // In unified mode, each adapter writes its OWN shimFile name.
             // In single-adapter mode, use selected adapter's shimFile.
-            const shimAdapter = ADAPTERS[name as AdapterId] || adapter;
+            const shimAdapter = ADAPTERS[name] || adapter;
             const shimFileName = (unified && !isSelectedAdapter)
-                ? (shimAdapter.shimFile || `${name.toUpperCase()}.md`)   // each adapter's own file
-                : (adapter.shimFile || `${name.toUpperCase()}.md`);       // selected adapter's file
-            
-            if (!dryRun) writeTextFile(path.join(projectRoot, shimFileName), shimContent);
+                ? (shimAdapter.shimFile || `${name.toUpperCase()}.md`) // each adapter's own file
+                : (adapter.shimFile || `${name.toUpperCase()}.md`); // selected adapter's file
+            if (!dryRun)
+                writeTextFile(path.join(projectRoot, shimFileName), shimContent);
             if (isSelectedAdapter) {
-                console.warn(`✅ Platform shim created: ${shimFileName}`);
-            } else if (unified) {
-                console.warn(`✅ Unified platform shim added: ${shimFileName}`);
+                console.warn(`[OK] Platform shim created: ${shimFileName}`);
+            }
+            else if (unified) {
+                console.warn(`[OK] Unified platform shim added: ${shimFileName}`);
             }
         }
     }

package/framework-mcp/dist/src/cli/commands/init/scaffold-docs.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { writeTextFile } from "../../utils/fs.js";
+import { getPackageRoot } from "../../utils/pkg.js";
+import { logger } from "../../../shared/logger.js";
+export function scaffoldProjectDocs(projectRoot, options, dryRun) {
+    if (dryRun)
+        return;
+    const docsDir = path.join(projectRoot, "docs");
+    if (!fs.existsSync(docsDir))
+        fs.mkdirSync(docsDir, { recursive: true });
+    // Scaffold tech-stack.md with dynamic content
+    const techStackPath = path.join(docsDir, "tech-stack.md");
+    let techStackContent = "";
+    try {
+        const templatePath = path.join(getPackageRoot(), "docs/tech-stack.md");
+        if (fs.existsSync(templatePath)) {
+            techStackContent = fs.readFileSync(templatePath, "utf8");
+            // Replace the backend language in the template
+            const lang = options.backendLanguage;
+            const frontend = options.frontendFramework || "Vite (React)";
+            techStackContent = techStackContent.replace(/\| \*\*Geliştirme Ortamı\*\* \| .* \|/, `| **Geliştirme Ortamı** | ${lang} |`);
+            techStackContent = techStackContent.replace(/\| \*\*Frontend Altyapısı\*\* \| .* \|/, `| **Frontend Altyapısı** | ${frontend} |`);
+        }
+    }
+    catch (e) {
+        logger.debug("Failed to read tech-stack.md template", e);
+    }
+    if (!techStackContent) {
+        techStackContent = `# 🛠️ Project Tech Stack\n\n- **Backend Language:** ${options.backendLanguage}\n- **Frontend Framework:** ${options.frontendFramework || "Vite (React)"}\n`;
+    }
+    writeTextFile(techStackPath, techStackContent);
+    console.warn(`[OK] Project documentation updated: docs/tech-stack.md (Backend: ${options.backendLanguage}, Frontend: ${options.frontendFramework || "Vite (React)"})`);
+}

package/{src/cli/commands/init/scaffold-ops.ts → framework-mcp/dist/src/cli/commands/init/scaffold-ops.js}

@@ -3,14 +3,13 @@ import path from "path";
 import { writeJsonFile, writeTextFile } from "../../utils/fs.js";
 import { getPackageRoot } from "../../utils/pkg.js";
 import { logger } from "../../../shared/logger.js";
-
-export function scaffoldOps(frameworkDir: string, dryRun: boolean) {
-    if (dryRun) return;
-
+export function scaffoldOps(frameworkDir, dryRun) {
+    if (dryRun)
+        return;
     // Scaffold Prompt Recipes
     const promptsPath = path.join(frameworkDir, "prompts");
-    if (!fs.existsSync(promptsPath)) fs.mkdirSync(promptsPath, { recursive: true });
-
+    if (!fs.existsSync(promptsPath))
+        fs.mkdirSync(promptsPath, { recursive: true });
     const recipes = [
         { file: "refactoring-recipe.md", template: "templates/prompts/refactoring-recipe.md" },
         { file: "bug-fix-recipe.md", template: "templates/prompts/bug-fix-recipe.md" },
@@ -21,7 +20,6 @@ export function scaffoldOps(frameworkDir: string, dryRun: boolean) {
         { file: "deployment-recipe.md", template: "templates/prompts/deployment-recipe.md" },
         { file: "contract-design-recipe.md", template: "templates/prompts/contract-design-recipe.md" }
     ];
-
     for (const recipe of recipes) {
         try {
             const fullTemplatePath = path.join(getPackageRoot(), recipe.template);
@@ -29,11 +27,11 @@ export function scaffoldOps(frameworkDir: string, dryRun: boolean) {
                 const content = fs.readFileSync(fullTemplatePath, "utf8");
                 writeTextFile(path.join(promptsPath, recipe.file), content);
             }
-        } catch (e) {
+        }
+        catch (e) {
             logger.debug(`Failed to scaffold prompt recipe: ${recipe.file}`, e);
         }
     }
-
     // Scaffold cli-commands.json
     const cliCommands = {
         commands: {
@@ -47,37 +45,36 @@ export function scaffoldOps(frameworkDir: string, dryRun: boolean) {
         }
     };
     writeJsonFile(path.join(frameworkDir, "cli-commands.json"), cliCommands, dryRun);
-
     // Scaffold router/routing_rules.md
     const routerDir = path.join(frameworkDir, "router");
-    if (!fs.existsSync(routerDir)) fs.mkdirSync(routerDir, { recursive: true });
-    writeTextFile(path.join(routerDir, "routing_rules.md"), "# 📡 Agent Atabey — Natural Language & Event Router\n\nRouting engine protocols defined here.");
-
+    if (!fs.existsSync(routerDir))
+        fs.mkdirSync(routerDir, { recursive: true });
+    writeTextFile(path.join(routerDir, "routing_rules.md"), "# [SIGNAL] Agent Atabey — Natural Language & Event Router\n\nRouting engine protocols defined here.");
     // Scaffold registry/agent_registry.md
     const registryDir = path.join(frameworkDir, "registry");
-    if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
-    writeTextFile(path.join(registryDir, "agent_registry.md"), "# 🎖️ Agent Atabey — Army Registry\n\nList of active agents.");
-
+    if (!fs.existsSync(registryDir))
+        fs.mkdirSync(registryDir, { recursive: true });
+    writeTextFile(path.join(registryDir, "agent_registry.md"), "# [ATABEY] Agent Atabey — Army Registry\n\nList of active agents.");
     // Scaffold observability files
     const obsDir = path.join(frameworkDir, "observability");
-    if (!fs.existsSync(obsDir)) fs.mkdirSync(obsDir, { recursive: true });
-    writeTextFile(path.join(obsDir, "audit_log.md"), "# 🎖️ Agent Atabey — Audit Log\n\n| Timestamp | Agent | Action | Trace ID | Status |\n|---|---|---|---|---|\n");
+    if (!fs.existsSync(obsDir))
+        fs.mkdirSync(obsDir, { recursive: true });
+    writeTextFile(path.join(obsDir, "audit_log.md"), "# [ATABEY] Agent Atabey — Audit Log\n\n| Timestamp | Agent | Action | Trace ID | Status |\n|---|---|---|---|---|\n");
     writeJsonFile(path.join(obsDir, "metrics.json"), []);
-
     // Scaffold .env.example
     const envExamplePath = path.join(process.cwd(), ".env.example");
     if (!fs.existsSync(envExamplePath)) {
         writeTextFile(envExamplePath, "# Agent Atabey - Environment Variables\n\n# Core Settings\nPORT=5858\nNODE_ENV=development\n\n# AI Platform Keys (Fill these in your local .env)\nGEMINI_API_KEY=\nCLAUDE_API_KEY=\nGROK_API_KEY=\n");
     }
-
     // Scaffold rules
     const rulesDir = path.join(frameworkDir, "rules");
-    if (!fs.existsSync(rulesDir)) fs.mkdirSync(rulesDir, { recursive: true });
+    if (!fs.existsSync(rulesDir))
+        fs.mkdirSync(rulesDir, { recursive: true });
     writeTextFile(path.join(rulesDir, "global_rules.mdc"), `---
 description: Global Rules for Agent Atabey Army
 globs: **/*
 ---
 
-# 🎖️ Agent Atabey — Global Army Rules
+# [ATABEY] Agent Atabey — Global Army Rules
 `);
 }

package/{src/cli/commands/init/scaffold-standards.ts → framework-mcp/dist/src/cli/commands/init/scaffold-standards.js}

@@ -3,24 +3,23 @@ import path from "path";
 import { ensureDir, writeTextFile } from "../../utils/fs.js";
 import { getPackageRoot } from "../../utils/pkg.js";
 import { CORE_SKILLS } from "../../../modules/skills/definitions.js";
-
 const FRAMEWORK_NAME = "Agent Atabey";
-
-export function scaffoldSkills(skillsBaseDir: string, dryRun: boolean) {
-    if (dryRun) return;
+export function scaffoldSkills(skillsBaseDir, dryRun) {
+    if (dryRun)
+        return;
     ensureDir(skillsBaseDir, dryRun);
     for (const [key, skill] of Object.entries(CORE_SKILLS)) {
-        const mdContent = `# 🛠️ ${FRAMEWORK_NAME} Skill — ${skill.name}\n\n${skill.description}\n\n## 🔌 Associated Tools\n${skill.tools.map(t => `- \`${t}\``).join("\n")}\n\n## 🛡️ Core Mandates\n${skill.mandates.join("\n")}\n`;
+        const mdContent = `# 🛠️ ${FRAMEWORK_NAME} Skill — ${skill.name}\n\n${skill.description}\n\n## 🔌 Associated Tools\n${skill.tools.map(t => `- \`${t}\``).join("\n")}\n\n## [SECURITY] Core Mandates\n${skill.mandates.join("\n")}\n`;
         writeTextFile(path.join(skillsBaseDir, `${key.toLowerCase()}.md`), mdContent);
     }
 }
-
-export function scaffoldStandards(frameworkDir: string, dryRun: boolean) {
-    if (dryRun) return;
+export function scaffoldStandards(frameworkDir, dryRun) {
+    if (dryRun)
+        return;
     const knowledgePath = path.join(frameworkDir, "knowledge");
-    if (!fs.existsSync(knowledgePath)) fs.mkdirSync(knowledgePath, { recursive: true });
-
-    const eslintStandardsContent = `# 🎖️ Agent Atabey — ESLint Standards
+    if (!fs.existsSync(knowledgePath))
+        fs.mkdirSync(knowledgePath, { recursive: true });
+    const eslintStandardsContent = `# [ATABEY] Agent Atabey — ESLint Standards
 
 This document outlines the strict ESLint coding standards for Agent Atabey projects.
 
@@ -32,28 +31,28 @@ This document outlines the strict ESLint coding standards for Agent Atabey proje
 - **Unused Variables:** Warning on unused variables unless prefixed with an underscore (\`_\`).
 `;
     writeTextFile(path.join(knowledgePath, "eslint-standards.md"), eslintStandardsContent);
-
     const standards = [
         // ── Supreme Governance (required by @manager, @security, @architect) ──────
-        { file: "governance-standards.md", template: "templates/standards/governance-standards.md", default: "# 🎖️ Agent Atabey — Governance & Nizam Standards" },
+        { file: "governance-standards.md", template: "templates/standards/governance-standards.md", default: "# [ATABEY] Agent Atabey — Governance & Nizam Standards" },
         // ── Core Engineering Standards ────────────────────────────────────────────
-        { file: "crud-governance.md", template: "templates/standards/crud-governance.md", default: "# 🏛️ Corporate CRUD and Governance Standards" },
+        { file: "crud-governance.md", template: "templates/standards/crud-governance.md", default: "# [GOV] Corporate CRUD and Governance Standards" },
         { file: "architecture-standards.md", template: "templates/standards/architecture-standards.md", default: "# 📐 Corporate Architecture Standards" },
         { file: "frontend-standards.md", template: "templates/standards/frontend-standards.md", default: "# 🎨 Corporate Frontend Standards" },
+        { file: "vite-standards.md", template: "templates/standards/vite-standards.md", default: "# ⚡ Corporate Vite Standards" },
+        { file: "nextjs-standards.md", template: "templates/standards/nextjs-standards.md", default: "# ⚛️ Corporate Next.js Standards" },
         { file: "tailwind-standards.md", template: "templates/standards/tailwind-standards.md", default: "# 🌊 Corporate Tailwind Standards" },
         { file: "mobile-standards.md", template: "templates/standards/mobile-standards.md", default: "# 📱 Corporate Mobile Standards" },
-        { file: "security-standards.md", template: "templates/standards/security-standards.md", default: "# 🛡️ Corporate Security Standards" },
+        { file: "security-standards.md", template: "templates/standards/security-standards.md", default: "# [SECURITY] Corporate Security Standards" },
         { file: "quality-standards.md", template: "templates/standards/quality-standards.md", default: "# ⚖️ Corporate Code Quality Standards" },
         { file: "logging-and-secrets.md", template: "templates/standards/logging-and-secrets.md", default: "# 🪵 Corporate Logging Standards" },
-        { file: "testing-standards.md", template: "templates/standards/testing-standards.md", default: "# 🧪 Corporate Testing Standards" },
+        { file: "testing-standards.md", template: "templates/standards/testing-standards.md", default: "# [SKILL] Corporate Testing Standards" },
         { file: "i18n-standards.md", template: "templates/standards/i18n-standards.md", default: "# 🌐 Corporate i18n Standards" },
-        { file: "llm-governance.md", template: "templates/standards/llm-governance.md", default: "# 🤖 LLM Governance Standards" },
+        { file: "llm-governance.md", template: "templates/standards/llm-governance.md", default: "# [AI] LLM Governance Standards" },
         { file: "observability-standards.md", template: "templates/standards/observability-standards.md", default: "# 📈 Corporate Observability Standards" },
-        { file: "deployment-standards.md", template: "templates/standards/deployment-standards.md", default: "# 🚀 Corporate Deployment Standards" },
+        { file: "deployment-standards.md", template: "templates/standards/deployment-standards.md", default: "# [START] Corporate Deployment Standards" },
         { file: "performance-standards.md", template: "templates/standards/performance-standards.md", default: "# ⚡ Corporate Performance Standards" },
         { file: "security-audit-standards.md", template: "templates/standards/security-audit-standards.md", default: "# 🔍 Corporate Security Audit Standards" }
     ];
-
     for (const std of standards) {
         let content = std.default;
         try {
@@ -61,7 +60,8 @@ This document outlines the strict ESLint coding standards for Agent Atabey proje
             if (fs.existsSync(fullTemplatePath)) {
                 content = fs.readFileSync(fullTemplatePath, "utf8");
             }
-        } catch { /* fallback to default */ }
+        }
+        catch { /* fallback to default */ }
         writeTextFile(path.join(knowledgePath, std.file), content);
     }
 }

package/{src/cli/commands/init.ts → framework-mcp/dist/src/cli/commands/init.js}

@@ -1,37 +1,17 @@
 import path from "path";
 import readline from "readline";
-
-import {
-    resolveAdapter,
-    runAdapterPostInit,
-    scaffoldAgents,
-    resolveAgentsDir,
-    mirrorUnifiedAgentsToNative,
-    ADAPTER_IDS,
-    type AdapterId,
-} from "../adapters/index.js";
+import { resolveAdapter, runAdapterPostInit, scaffoldAgents, resolveAgentsDir, mirrorUnifiedAgentsToNative, ADAPTER_IDS, } from "../adapters/index.js";
 import { ensureDir } from "../utils/fs.js";
 import { initializeMemory, getConfiguredPaths } from "../utils/memory.js";
-import { getPackageVersion } from "../utils/pkg.js";
+import { getPackageVersion, getPackageRoot, mergePackageJson } from "../utils/pkg.js";
 import { UI } from "../utils/ui.js";
-
 import { ALL_AGENTS } from "../../modules/agents/definitions.js";
-import { 
-    scaffoldConstitution, 
-    scaffoldFrameworkConfigs, 
-    scaffoldShims 
-} from "./init/scaffold-core.js";
-import { 
-    scaffoldSkills, 
-    scaffoldStandards 
-} from "./init/scaffold-standards.js";
+import { scaffoldConstitution, scaffoldFrameworkConfigs, scaffoldShims } from "./init/scaffold-core.js";
+import { scaffoldSkills, scaffoldStandards } from "./init/scaffold-standards.js";
 import { scaffoldOps } from "./init/scaffold-ops.js";
 import { scaffoldProjectDocs } from "./init/scaffold-docs.js";
-
-import { TRANSLATIONS, type SupportedLanguage } from "../utils/i18n.js";
-
+import { TRANSLATIONS } from "../utils/i18n.js";
 const FRAMEWORK_NAME = "Agent Atabey";
-
 const FRAMEWORK_SUBDIRS = [
     "agents",
     "skills",
@@ -43,151 +23,145 @@ const FRAMEWORK_SUBDIRS = [
     "observability",
     "rules",
 ];
-
-async function runInteractiveInit(): Promise<{ selectedDirs: string[], selectedAgents: string[], selectedPalette: string, backendLanguage: string, language: SupportedLanguage }> {
+async function runInteractiveInit() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const question = (query: string): Promise<string> => new Promise((resolve) => rl.question(query, resolve));
-
+    const question = (query) => new Promise((resolve) => rl.question(query, resolve));
     try {
         console.warn("\n🌐 Select Framework Language / Dil Seçimi:");
         console.warn("1. Türkçe");
         console.warn("2. English");
         const langInput = await question("\nSelect (1-2) or Enter for 'tr': ");
-        const language: SupportedLanguage = langInput.trim() === "2" ? "en" : "tr";
+        const language = langInput.trim() === "2" ? "en" : "tr";
         const t = TRANSLATIONS[language];
-
-        console.warn(`\n🚀 ${t.welcome}`);
-        
+        console.warn(`\n[START] ${t.welcome}`);
         console.warn(`\n${t.select_backend}:`);
         const languages = ["Node.js (TypeScript)", "Go", "Java (Spring Boot)", "Python (FastAPI)", ".NET"];
         languages.forEach((l, i) => console.warn(`${i + 1}. ${l}`));
         const bLangInput = await question("\nSelect (1-5) or Enter for \"Node.js\": ");
         const backendLanguage = languages[parseInt(bLangInput.trim()) - 1] || "Node.js (TypeScript)";
-
+        console.warn(`\n${t.select_frontend}:`);
+        const frontendFrameworks = ["Vite (React)", "Next.js (App Router)", "Vanilla HTML/JS"];
+        frontendFrameworks.forEach((f, i) => console.warn(`${i + 1}. ${f}`));
+        const fFrameInput = await question("\nSelect (1-3) or Enter for \"Vite (React)\": ");
+        const frontendFramework = frontendFrameworks[parseInt(fFrameInput.trim()) - 1] || "Vite (React)";
         console.warn("\nAvailable Framework Directories:");
         FRAMEWORK_SUBDIRS.forEach((d, i) => console.warn(`${i + 1}. ${d}`));
         const dirInput = await question(`\n${t.select_dirs} `);
         const selectedDirs = dirInput ? dirInput.split(",").map(n => FRAMEWORK_SUBDIRS[parseInt(n.trim()) - 1]).filter(Boolean) : [...FRAMEWORK_SUBDIRS];
-
         console.warn("\nAvailable Core Agents:");
         ALL_AGENTS.forEach((a, i) => console.warn(`${i + 1}. ${a.name}`));
         const agentInput = await question(`\n${t.select_agents} `);
         const selectedAgents = agentInput ? agentInput.split(",").map(n => ALL_AGENTS[parseInt(n.trim()) - 1].name).filter(Boolean) : ALL_AGENTS.map(a => a.name);
-
         console.warn("\nAvailable Color Palettes:");
         const palettes = ["Modern Blue", "Enterprise Slate", "Deep Purple"];
         palettes.forEach((p, i) => console.warn(`${i + 1}. ${p}`));
         const palInput = await question(`\n${t.select_palette} `);
         const selectedPalette = palettes[parseInt(palInput.trim()) - 1] || "Modern Blue";
-
-        return { selectedDirs, selectedAgents, selectedPalette, backendLanguage, language };
-    } finally { rl.close(); }
+        return { selectedDirs, selectedAgents, selectedPalette, backendLanguage, frontendFramework, language };
+    }
+    finally {
+        rl.close();
+    }
 }
-
-export async function initCommand(adapterName: string, options: { unified?: boolean, dryRun?: boolean, yes?: boolean }) {
-    const adapterId = (adapterName || "gemini") as AdapterId;
+export async function initCommand(adapterName, options) {
+    const adapterId = (adapterName || "gemini");
     const adapter = resolveAdapter(adapterId);
-
     if (!adapter) {
         UI.error(`Unknown adapter: ${adapterId}`);
         process.exit(1);
     }
-
     const projectRoot = process.cwd();
     const isUnified = options.unified || false;
-
     // STRICT ISOLATION STRATEGY
     const coreDir = ".atabey"; // Pure Memory & Knowledge
     const aiToolDir = isUnified ? ".agents" : adapter.frameworkDir; // Pure Agents & Skills
-
     const dryRun = options.dryRun || false;
     const forceYes = options.yes || false;
-
     UI.intent("Atabey Initialization", `Bootstrapping ${FRAMEWORK_NAME} (v${getPackageVersion()}) with ${adapterId} adapter...`);
-
-    let selectedDirs: string[];
-    let selectedAgents: string[];
-    let selectedPalette: string;
-    let backendLanguage: string;
-    let language: SupportedLanguage;
-
+    let selectedDirs;
+    let selectedAgents;
+    let selectedPalette;
+    let backendLanguage;
+    let frontendFramework;
+    let language;
     if (forceYes) {
         selectedDirs = ["knowledge", "prompts", "memory", "router", "registry", "observability", "rules"];
         selectedAgents = ALL_AGENTS.map(a => a.name);
         selectedPalette = "Modern Blue";
         backendLanguage = "Node.js (TypeScript)";
+        frontendFramework = "Vite (React)";
         language = "tr";
-        UI.success("Non-interactive mode: Using default configurations (Language: tr, Backend: Node.js).");
-    } else {
+        UI.success("Non-interactive mode: Using default configurations (Language: tr, Backend: Node.js, Frontend: Vite).");
+    }
+    else {
         const result = await runInteractiveInit();
         selectedDirs = result.selectedDirs.filter(d => d !== "agents" && d !== "skills");
         selectedAgents = result.selectedAgents;
         selectedPalette = result.selectedPalette;
         backendLanguage = result.backendLanguage;
+        frontendFramework = result.frontendFramework;
         language = result.language;
     }
-
     const t = TRANSLATIONS[language];
-
     ensureDir(path.join(projectRoot, coreDir), dryRun);
     selectedDirs.forEach(dir => {
         ensureDir(path.join(projectRoot, coreDir, dir), dryRun);
     });
-
     ensureDir(path.join(projectRoot, aiToolDir), dryRun);
     if (adapter.nestedDirs) {
         adapter.nestedDirs.forEach(dir => ensureDir(path.join(projectRoot, aiToolDir, dir), dryRun));
     }
-
     scaffoldConstitution(projectRoot, coreDir, adapterId, dryRun, language);
     scaffoldFrameworkConfigs(projectRoot, coreDir, adapter, dryRun, selectedPalette, {
         unified: isUnified,
         adapters: isUnified ? [...ADAPTER_IDS] : [adapterId],
         backendLanguage,
+        frontendFramework,
         language
     });
-
     scaffoldStandards(path.join(projectRoot, coreDir), dryRun);
-
     const pathsMap = getConfiguredPaths();
-
     if (isUnified) {
         // Scaffold ALL agents for ALL adapters under unified hub
         for (const id of ADAPTER_IDS) {
-            const adapterId = id as AdapterId;
+            const adapterId = id;
             const dest = resolveAgentsDir(adapterId, true, aiToolDir);
             scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
-            if (!dryRun) mirrorUnifiedAgentsToNative(projectRoot, adapterId);
+            if (!dryRun)
+                mirrorUnifiedAgentsToNative(projectRoot, adapterId);
         }
-        UI.success(`✅ Scaffolding complete for all adapters under ${aiToolDir}/ with native mirrors.`);
-    } else {
+        UI.success(`[OK] Scaffolding complete for all adapters under ${aiToolDir}/ with native mirrors.`);
+    }
+    else {
         // Standard single-adapter scaffold
         const dest = resolveAgentsDir(adapterId, false);
         scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
-        UI.success(`✅ Generated agent definitions under ${dest.agentsDir}/`);
+        UI.success(`[OK] Generated agent definitions under ${dest.agentsDir}/`);
     }
-
     const skillsBaseDir = path.join(projectRoot, aiToolDir, "skills");
     scaffoldSkills(skillsBaseDir, dryRun);
     scaffoldOps(path.join(projectRoot, coreDir), dryRun);
-    scaffoldProjectDocs(projectRoot, { backendLanguage }, dryRun);
+    scaffoldProjectDocs(projectRoot, { backendLanguage, frontendFramework }, dryRun);
     scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun, isUnified);
-
     // Initialize runtime directories
     if (!dryRun) {
         ensureDir(path.join(projectRoot, coreDir, "messages"));
         ensureDir(path.join(projectRoot, coreDir, "logs"));
         ensureDir(path.join(projectRoot, coreDir, "memory-graph"));
     }
-
     initializeMemory(path.join(projectRoot, coreDir), dryRun);
+    // Scaffolding package.json
+    if (!dryRun) {
+        const pkgJsonPath = path.join(projectRoot, "package.json");
+        const sourcePkgPath = path.join(getPackageRoot(), "package.json");
+        mergePackageJson(pkgJsonPath, sourcePkgPath);
+    }
     runAdapterPostInit(adapter, projectRoot);
-
-    UI.success(`\n🚀 ${FRAMEWORK_NAME} (v${getPackageVersion()}) ${t.init_success}`);
+    UI.success(`\n[START] ${FRAMEWORK_NAME} (v${getPackageVersion()}) ${t.init_success}`);
     console.warn(`\n- Brain & Memory Hub (Protected): ${coreDir}/`);
     console.warn(`- AI Agent Commands (Active): ${aiToolDir}/`);
     console.warn(`\n${t.next_steps}`);
-    console.warn("  1. Run 'atabey status' to verify the environment.");
-    console.warn(`  2. Open ${adapterId === "claude" ? "Claude Desktop" : "your AI Assistant"} and start commanding the Army.`);
+    console.warn("  1. Run 'npm install' (or pnpm/yarn) to install dependencies.");
+    console.warn("  2. Run 'atabey status' to verify the environment.");
+    console.warn(`  3. Open ${adapterId === "claude" ? "Claude Desktop" : "your AI Assistant"} and start commanding the Army.`);
 }
-