atabey 0.0.2 → 0.0.4

package/framework-mcp/dist/utils/cli.js

@@ -1,20 +1,58 @@
+import fs from "fs";
+import path from "path";
 import { execFileSync } from "child_process";
 /**
- * Executes a CLI command safely using execFileSync (no shell injection risk).
- * Captures stderr gracefully to prevent stream crashes.
+ * Executes a command safely and returns the output.
  */
-export function safeExec(command, args, cwd, timeout) {
+export function safeExec(cmd, args, cwd, timeout = 30000) {
     try {
-        return execFileSync(command, args, {
-            cwd,
-            encoding: "utf8",
-            timeout: timeout || 30000,
-            maxBuffer: 1024 * 1024,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
+        return execFileSync(cmd, args, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
     }
-    catch (error) {
-        const err = error;
-        throw new Error(err.stderr || err.message || "Command execution failed", { cause: error });
+    catch (err) {
+        return err.stdout?.toString() || err.stderr?.toString() || err.message;
     }
 }
+/**
+ * Detects the backend language from the framework configuration.
+ */
+export function getBackendLanguage(projectRoot) {
+    try {
+        const configPath = path.join(projectRoot, ".atabey", "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return config.backendLanguage || "Node.js (TypeScript)";
+        }
+    }
+    catch {
+        // Fallback to default
+    }
+    return "Node.js (TypeScript)";
+}
+/**
+ * Returns the default lint command for the given language.
+ */
+export function getDefaultLintCommand(language) {
+    if (language.includes("Go"))
+        return "go fmt ./...";
+    if (language.includes("Java"))
+        return "./gradlew check"; // or mvn check
+    if (language.includes("Python"))
+        return "ruff check .";
+    if (language.includes(".NET"))
+        return "dotnet format";
+    return "npm run lint";
+}
+/**
+ * Returns the default test command for the given language.
+ */
+export function getDefaultTestCommand(language) {
+    if (language.includes("Go"))
+        return "go test ./...";
+    if (language.includes("Java"))
+        return "./gradlew test"; // or mvn test
+    if (language.includes("Python"))
+        return "pytest";
+    if (language.includes(".NET"))
+        return "dotnet test";
+    return "npm test";
+}

package/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atabey/mcp",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "Agent Atabey Model Context Protocol (MCP) Server",
   "author": "Yusuf BEKAR",
   "license": "MIT",

package/framework-mcp/src/tools/definitions.ts

@@ -132,7 +132,7 @@ export const TOOLS: ToolDefinition[] = [
         inputSchema: {
             type: "object",
             properties: {
-                command: { type: "string", description: "The test command to run (default: 'npm test')" }
+                command: { type: "string", description: "The test command to run (default: project's standard test command)" }
             }
         }
     },

package/framework-mcp/src/tools/framework/run_tests.ts

@@ -1,16 +1,18 @@
 import { execSync } from "child_process";
 import { RunTestsArgs, ToolResult } from "../types.js";
+import { getBackendLanguage, getDefaultTestCommand } from "../../utils/cli.js";
 
 /**
  * Executes project tests and returns results for agent analysis.
  */
 export function handleRunTests(projectRoot: string, args: RunTestsArgs): ToolResult {
-    const testCommand = args.command || "npm test";
+    const language = getBackendLanguage(projectRoot);
+    const testCommand = args.command || getDefaultTestCommand(language);
     
     try {
         const output = execSync(testCommand, { cwd: projectRoot, encoding: "utf8", stdio: "pipe" });
         return {
-            content: [{ type: "text", text: `✅ Tests passed successfully!\n\n${output}` }]
+            content: [{ type: "text", text: `✅ Tests passed successfully for ${language}!\n\n${output}` }]
         };
     } catch (error: unknown) {
         const err = error as { stderr?: Buffer; stdout?: Buffer };
@@ -21,7 +23,7 @@ export function handleRunTests(projectRoot: string, args: RunTestsArgs): ToolRes
             isError: true,
             content: [{ 
                 type: "text", 
-                text: `❌ Tests FAILED!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}` 
+                text: `❌ Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}` 
             }]
         };
     }

package/framework-mcp/src/tools/quality/check_lint.ts

@@ -1,32 +1,35 @@
 import { exec } from "child_process";
 import { ToolArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
+import { getBackendLanguage, getDefaultLintCommand } from "../../utils/cli.js";
 
-const LINT_COMMAND = "npm run lint";
 const TIMEOUT = 60000; // 60 seconds
 
 /**
  * Handles running the project's linter.
  */
 export function handleCheckLint(projectRoot: string, _args: ToolArgs): Promise<ToolResult> {
+    const language = getBackendLanguage(projectRoot);
+    const lintCommand = getDefaultLintCommand(language);
+
     return new Promise((resolve) => {
-        exec(LINT_COMMAND, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
+        exec(lintCommand, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
             const output = stdout + stderr;
             const tokens = Metrics.estimateTokens(output);
             
             if (error) {
-                const err = `Linting failed: ${error.message}`;
+                const err = `Linting failed for ${language} with command: ${lintCommand}. ${error.message}`;
                 Metrics.logError(projectRoot, "@mcp", "check_lint", err);
                 resolve({
                     isError: true,
-                    content: [{ type: "text", text: `❌ Lint Errors Found:\n\n${output}` }]
+                    content: [{ type: "text", text: `❌ Lint Errors Found (${language}):\n\n${output}` }]
                 });
                 return;
             }
 
             Metrics.logUsage(projectRoot, "@mcp", "check_lint", tokens);
             resolve({
-                content: [{ type: "text", text: `✅ Lint check passed successfully:\n\n${output}` }]
+                content: [{ type: "text", text: `✅ Lint check passed successfully for ${language}:\n\n${output}` }]
             });
         });
     });

package/framework-mcp/src/tools/shell/run_command.ts

@@ -5,10 +5,20 @@ import { Metrics } from "../../utils/metrics.js";
 const COMMAND_ALLOW_LIST = [
     "npm test",
     "npm run lint",
+    "npm run build",
     "git status",
     "git diff",
-    "npx vitest run", // From the audit, this is the test command
-    "npm run build", // From the audit
+    "npx vitest run",
+    "go test",
+    "go fmt",
+    "go build",
+    "pytest",
+    "ruff check",
+    "dotnet test",
+    "dotnet format",
+    "dotnet build",
+    "./gradlew",
+    "mvn",
 ];
 
 const TIMEOUT = 30000; // 30 seconds

package/framework-mcp/src/utils/cli.ts

@@ -1,20 +1,52 @@
+import fs from "fs";
+import path from "path";
 import { execFileSync } from "child_process";
 
 /**
- * Executes a CLI command safely using execFileSync (no shell injection risk).
- * Captures stderr gracefully to prevent stream crashes.
+ * Executes a command safely and returns the output.
  */
-export function safeExec(command: string, args: string[], cwd: string, timeout?: number): string {
+export function safeExec(cmd: string, args: string[], cwd: string, timeout = 30000): string {
     try {
-        return execFileSync(command, args, {
-            cwd,
-            encoding: "utf8",
-            timeout: timeout || 30000,
-            maxBuffer: 1024 * 1024,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-    } catch (error: unknown) {
-        const err = error as { stderr?: string; message?: string };
-        throw new Error(err.stderr || err.message || "Command execution failed", { cause: error });
+        return execFileSync(cmd, args, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
+    } catch (err: any) {
+        return err.stdout?.toString() || err.stderr?.toString() || err.message;
     }
 }
+
+/**
+ * Detects the backend language from the framework configuration.
+ */
+export function getBackendLanguage(projectRoot: string): string {
+    try {
+        const configPath = path.join(projectRoot, ".atabey", "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return config.backendLanguage || "Node.js (TypeScript)";
+        }
+    } catch {
+        // Fallback to default
+    }
+    return "Node.js (TypeScript)";
+}
+
+/**
+ * Returns the default lint command for the given language.
+ */
+export function getDefaultLintCommand(language: string): string {
+    if (language.includes("Go")) return "go fmt ./...";
+    if (language.includes("Java")) return "./gradlew check"; // or mvn check
+    if (language.includes("Python")) return "ruff check .";
+    if (language.includes(".NET")) return "dotnet format";
+    return "npm run lint";
+}
+
+/**
+ * Returns the default test command for the given language.
+ */
+export function getDefaultTestCommand(language: string): string {
+    if (language.includes("Go")) return "go test ./...";
+    if (language.includes("Java")) return "./gradlew test"; // or mvn test
+    if (language.includes("Python")) return "pytest";
+    if (language.includes(".NET")) return "dotnet test";
+    return "npm test";
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atabey",
-  "version": "0.0.2",
-  "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AI Management Assistant.",
+  "version": "0.0.4",
+  "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Supports Polyglot Backends (Go, Java, Python, .NET, Node.js) and Multi-Language Communication (TR/EN).",
   "author": "Yusuf BEKAR",
   "license": "MIT",
   "readme": "README.md",

package/src/cli/adapters/core.ts

@@ -27,20 +27,44 @@ export const FRAMEWORK_DIR_CANDIDATES = [
 export function buildMcpServerEntry(projectRoot: string) {
     const packageRoot = getPackageRoot();
     
-    // Check both local development workspace path and installed node_modules path
-    let mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
-    if (!fs.existsSync(mcpServerPath)) {
-        mcpServerPath = path.join(packageRoot, "../@atabey/mcp/dist/index.js");
-    }
-    if (!fs.existsSync(mcpServerPath)) {
-        mcpServerPath = path.join(projectRoot, "node_modules/@atabey/mcp/dist/index.js");
-    }
+    // Check if we are running in the framework local development repository itself
+    const isLocalFrameworkDev = path.resolve(packageRoot) === path.resolve(projectRoot);
 
-    if (!fs.existsSync(mcpServerPath)) {
-        console.warn("⚠️  MCP Server not found. Did you run 'npm run build' inside @atabey/mcp?");
-    }
+    let relativePath = "";
 
-    const relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
+    if (isLocalFrameworkDev) {
+        // In local framework dev, always use the build path directly relative to project root
+        let mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
+        if (!fs.existsSync(mcpServerPath)) {
+            mcpServerPath = path.join(packageRoot, "../@atabey/mcp/dist/index.js");
+        }
+        if (!fs.existsSync(mcpServerPath)) {
+            mcpServerPath = path.join(projectRoot, "node_modules/@atabey/mcp/dist/index.js");
+        }
+
+        if (!fs.existsSync(mcpServerPath)) {
+            console.warn("⚠️  MCP Server not found. Did you run 'npm run build' inside @atabey/mcp?");
+        }
+        relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
+    } else {
+        // If we are initializing in a user's project:
+        // We want to target the local node_modules of the user's project.
+        // Even if node_modules is not populated yet (e.g. running via npx before npm install),
+        // we should write the local node_modules path so that it will work once installed.
+        
+        const localAtabeyPath = path.join(projectRoot, "node_modules/atabey/framework-mcp/dist/index.js");
+        const localScopedPath = path.join(projectRoot, "node_modules/@atabey/mcp/dist/index.js");
+
+        if (fs.existsSync(localScopedPath)) {
+            relativePath = path.relative(projectRoot, localScopedPath);
+        } else if (fs.existsSync(localAtabeyPath)) {
+            relativePath = path.relative(projectRoot, localAtabeyPath);
+        } else {
+            // Default to the standard relative local path in node_modules/atabey
+            // This is clean and portable across machines/developers.
+            relativePath = "node_modules/atabey/framework-mcp/dist/index.js";
+        }
+    }
 
     return {
         command: "node",

package/src/cli/adapters/scaffold.ts

@@ -21,7 +21,9 @@ export function scaffoldAgents(
     agentsToScaffold?: string[],
     explicitDestDir?: string,
     explicitExt?: string,
-    paths?: Record<string, string>
+    paths?: Record<string, string>,
+    backendLanguage?: string,
+    language?: string
 ): void {
     const adapter = ADAPTERS[adapterId];
     if (!adapter) return;
@@ -47,27 +49,27 @@ export function scaffoldAgents(
 
             switch (adapterId) {
                 case "gemini":
-                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
                 case "grok":
                     // Grok uses same Gemini-compatible YAML format
-                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
                 case "claude":
-                    content = toClaudeCodeMd(agent, baseKnowledgeDir, paths);
+                    content = toClaudeCodeMd(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
                 case "cursor":
-                    content = toCursorMdc(agent, baseKnowledgeDir, paths);
+                    content = toCursorMdc(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
                 case "codex":
-                    content = toCodexMd(agent, baseKnowledgeDir, paths);
+                    content = toCodexMd(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
                 case "antigravity-cli": {
                     // Antigravity uses nested folders: agents/{name}/agent.json and agents/{name}/agent.md
                     const agentDir = path.join(destAgentsDir, agent.name);
                     if (!dryRun) fs.mkdirSync(agentDir, { recursive: true });
                     
-                    content = toAntigravityJson(agent, baseKnowledgeDir, paths);
+                    content = toAntigravityJson(agent, baseKnowledgeDir, paths, backendLanguage);
                     fileName = path.join(agent.name, "agent.json");
                     
                     secondaryContent = `# 🎖️ Agent Atabey — @${agent.name}\n\n${agent.instructions.identity}\n\n${agent.instructions.mission}`;
@@ -76,7 +78,7 @@ export function scaffoldAgents(
                 }
                 default:
                     // Fallback to Gemini format
-                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
                     break;
             }
 

package/src/cli/commands/init/scaffold-core.ts

@@ -11,6 +11,8 @@ 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";
+
 const FRAMEWORK_NAME = "Agent Atabey";
 
 const COLOR_PALETTES = {
@@ -19,9 +21,10 @@ const COLOR_PALETTES = {
     "Deep Purple": { primary: "#8b5cf6", secondary: "#d8b4fe", accent: "#f59e0b" }
 };
 
-export function scaffoldConstitution(targetDir: string, frameworkDir: string, adapterId: AdapterId, dryRun: boolean) {
+export function scaffoldConstitution(targetDir: string, frameworkDir: string, adapterId: AdapterId, dryRun: boolean, language: SupportedLanguage = "tr") {
     if (dryRun) return;
-    let content = `# 🎖️ ${FRAMEWORK_NAME} — Constitution\n\nDiscipline and Order.`;
+    const t = TRANSLATIONS[language];
+    let content = `# 🎖️ ${t.constitution_title}\n\nDiscipline and Order.`;
     let readSuccess = false;
     try {
         const templatePath = path.join(getPackageRoot(), "ATABEY.md");
@@ -45,17 +48,21 @@ export function scaffoldFrameworkConfigs(
     adapter: AdapterConfig, 
     dryRun: boolean, 
     selectedPalette: string,
-    options?: { unified?: boolean; adapters?: string[] }
+    options?: { unified?: boolean; adapters?: string[]; backendLanguage?: string; language?: SupportedLanguage }
 ) {
     if (dryRun) return;
     const frameworkDir = path.join(targetDir, fDir);
     const palette = COLOR_PALETTES[selectedPalette as keyof typeof COLOR_PALETTES] || 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)",
+        language: language,
         theme: {
             palette: selectedPalette,
             colors: palette
@@ -71,12 +78,13 @@ export function scaffoldFrameworkConfigs(
         writeJsonFile(sharedFactsPath, {
             project: FRAMEWORK_NAME,
             initializedAt: new Date().toISOString(),
-            stack: [],
+            stack: [options?.backendLanguage || "Node.js (TypeScript)"],
+            language: language,
             policies: []
         }, dryRun);
     }
 
-    let statusContent = "# 🎖️ Status\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n";
+    let statusContent = `# 🎖️ ${t.status_title}\n\n| Agent | State | Active Task | Last Updated | Notes | Extra | Backup |\n|---|---|---|---|---|---|---|\n`;
     
     const activeAgents = ALL_AGENTS;
 
@@ -84,7 +92,7 @@ export function scaffoldFrameworkConfigs(
     const now = new Date().toISOString();
 
     for (const ag of activeAgents) {
-        statusContent += "| @" + ag.name + " | READY | Idle | - | - | - | - |\n";
+        statusContent += "| @" + ag.name + " | " + t.agent_ready + " | Idle | - | - | - | - |\n";
         initialStatusJson[ag.name] = { state: "READY", task: "Idle", lastUpdated: now };
     }
     writeTextFile(path.join(frameworkDir, "STATUS.md"), statusContent);

package/src/cli/commands/init/scaffold-docs.ts

@@ -0,0 +1,44 @@
+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: string, options: { backendLanguage: string }, dryRun: boolean) {
+    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
+            // Assuming the template has a row like: | **Backend Altyapısı** | Node.js v20+ & TypeScript v5+ | ... |
+            // We'll use a more generic replacement or just append/update the specific section.
+            const lang = options.backendLanguage;
+            
+            // If it's a new project, we can just rewrite the table or use a placeholder in the template.
+            // For now, let's assume we want to update the "Backend" or "Geliştirme Ortamı" row.
+            techStackContent = techStackContent.replace(
+                /\| \*\*Geliştirme Ortamı\*\* \| .* \|/,
+                `| **Geliştirme Ortamı** | ${lang} |`
+            );
+        }
+    } 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`;
+    }
+
+    writeTextFile(techStackPath, techStackContent);
+    console.warn(`✅ Project documentation updated: docs/tech-stack.md (Language: ${options.backendLanguage})`);
+}

package/src/cli/commands/init.ts

@@ -26,6 +26,9 @@ import {
     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";
 
 const FRAMEWORK_NAME = "Agent Atabey";
 
@@ -41,29 +44,43 @@ const FRAMEWORK_SUBDIRS = [
     "rules",
 ];
 
-async function runInteractiveInit(): Promise<{ selectedDirs: string[], selectedAgents: string[], selectedPalette: string }> {
+async function runInteractiveInit(): Promise<{ selectedDirs: string[], selectedAgents: string[], selectedPalette: string, backendLanguage: string, language: SupportedLanguage }> {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const question = (query: string): Promise<string> => new Promise((resolve) => rl.question(query, resolve));
 
     try {
-        console.warn(`\n🚀 Welcome to ${FRAMEWORK_NAME} Interactive Setup!`);
-        console.warn("\nAvailable Framework Directories:");
+        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 t = TRANSLATIONS[language];
+
+        console.warn(`\n🚀 ${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(`\nAvailable Framework Directories:`);
         FRAMEWORK_SUBDIRS.forEach((d, i) => console.warn(`${i + 1}. ${d}`));
-        const dirInput = await question("\nEnter directory numbers to include (e.g. 1,2,3) or Enter for ALL: ");
+        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:");
+        console.warn(`\nAvailable Core Agents:`);
         ALL_AGENTS.forEach((a, i) => console.warn(`${i + 1}. ${a.name}`));
-        const agentInput = await question("\nEnter agent numbers to include (e.g. 1,2) or Enter for ALL: ");
+        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:");
+        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("\nSelect palette (1-3) or Enter for 'Modern Blue': ");
+        const palInput = await question(`\n${t.select_palette} `);
         const selectedPalette = palettes[parseInt(palInput.trim()) - 1] || "Modern Blue";
 
-        return { selectedDirs, selectedAgents, selectedPalette };
+        return { selectedDirs, selectedAgents, selectedPalette, backendLanguage, language };
     } finally { rl.close(); }
 }
 
@@ -91,19 +108,27 @@ export async function initCommand(adapterName: string, options: { unified?: bool
     let selectedDirs: string[];
     let selectedAgents: string[];
     let selectedPalette: string;
+    let backendLanguage: string;
+    let language: SupportedLanguage;
 
     if (forceYes) {
         selectedDirs = ["knowledge", "prompts", "memory", "router", "registry", "observability", "rules"];
         selectedAgents = ALL_AGENTS.map(a => a.name);
         selectedPalette = "Modern Blue";
-        UI.success(`Non-interactive mode: Using default configurations.`);
+        backendLanguage = "Node.js (TypeScript)";
+        language = "tr";
+        UI.success(`Non-interactive mode: Using default configurations (Language: tr, Backend: Node.js).`);
     } else {
         const result = await runInteractiveInit();
         selectedDirs = result.selectedDirs.filter(d => d !== "agents" && d !== "skills");
         selectedAgents = result.selectedAgents;
         selectedPalette = result.selectedPalette;
+        backendLanguage = result.backendLanguage;
+        language = result.language;
     }
 
+    const t = TRANSLATIONS[language];
+
     ensureDir(path.join(projectRoot, coreDir), dryRun);
     selectedDirs.forEach(dir => {
         ensureDir(path.join(projectRoot, coreDir, dir), dryRun);
@@ -114,10 +139,12 @@ export async function initCommand(adapterName: string, options: { unified?: bool
         adapter.nestedDirs.forEach(dir => ensureDir(path.join(projectRoot, aiToolDir, dir), dryRun));
     }
 
-    scaffoldConstitution(projectRoot, coreDir, adapterId, dryRun);
+    scaffoldConstitution(projectRoot, coreDir, adapterId, dryRun, language);
     scaffoldFrameworkConfigs(projectRoot, coreDir, adapter, dryRun, selectedPalette, {
         unified: isUnified,
-        adapters: isUnified ? [...ADAPTER_IDS] : [adapterId]
+        adapters: isUnified ? [...ADAPTER_IDS] : [adapterId],
+        backendLanguage,
+        language
     });
 
     scaffoldStandards(path.join(projectRoot, coreDir), dryRun);
@@ -127,21 +154,23 @@ export async function initCommand(adapterName: string, options: { unified?: bool
     if (isUnified) {
         // Scaffold ALL agents for ALL adapters under unified hub
         for (const id of ADAPTER_IDS) {
-            const dest = resolveAgentsDir(id, true, aiToolDir);
-            scaffoldAgents(projectRoot, id, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap);
-            if (!dryRun) mirrorUnifiedAgentsToNative(projectRoot, id);
+            const adapterId = id as AdapterId;
+            const dest = resolveAgentsDir(adapterId, true, aiToolDir);
+            scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
+            if (!dryRun) mirrorUnifiedAgentsToNative(projectRoot, adapterId);
         }
         UI.success(`✅ 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);
+        scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
         UI.success(`✅ 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);
     scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun, isUnified);
 
     // Initialize runtime directories
@@ -154,10 +183,11 @@ export async function initCommand(adapterName: string, options: { unified?: bool
     initializeMemory(path.join(projectRoot, coreDir), dryRun);
     runAdapterPostInit(adapter, projectRoot);
 
-    UI.success(`\n🚀 ${FRAMEWORK_NAME} (v${getPackageVersion()}) initialized successfully!`);
+    UI.success(`\n🚀 ${FRAMEWORK_NAME} (v${getPackageVersion()}) ${t.init_success}`);
     console.warn(`\n- Brain & Memory Hub (Protected): ${coreDir}/`);
     console.warn(`- AI Agent Commands (Active): ${aiToolDir}/`);
-    console.warn("\nNext Steps:");
+    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.`);
 }
+