atabey 0.0.7 → 0.0.8

package/framework-mcp/dist/src/cli/commands/compliance.js

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { collectFiles } from "../utils/fs.js";
+const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
+export async function complianceCheckCommand(targetPath) {
+    console.warn(`📜 Checking Constitution Compliance: ${targetPath}...`);
+    const violations = [];
+    const forbidden = ["@shadcn", "mui", "@chakra-ui", "tailwindcss"];
+    // 1. package.json scan (Blind Spot 5)
+    const pkgJsonPath = path.join(targetDir, "package.json");
+    if (fs.existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+            const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            forbidden.forEach(lib => {
+                if (allDeps[lib] || Object.keys(allDeps).some(d => d.toLowerCase().includes(lib.toLowerCase()))) {
+                    violations.push(`package.json: Forbidden library dependency '${lib}' found in package.json.`);
+                }
+            });
+        }
+        catch {
+            // ignore
+        }
+    }
+    // 2. Source files scan
+    const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx", ".js", ".jsx", ".md"]);
+    files.forEach(f => {
+        const isTypesFile = f.includes("brands.ts") || f.includes("brands.js") || f.includes("brands.tsx") || f.includes("src/types/brands");
+        const content = fs.readFileSync(f, "utf8");
+        forbidden.forEach(lib => {
+            if (content.includes(lib))
+                violations.push(`${path.relative(targetDir, f)}: Forbidden library '${lib}' found.`);
+        });
+        // Robust Branded Types validation (Blind Spot 4)
+        if ((f.endsWith(".ts") || f.endsWith(".tsx")) && !isTypesFile && content.includes("interface")) {
+            const plainIdMatches = content.match(/\b\w*(?:id|Id|ID)\??\s*:\s*(?:string|number)\b/g);
+            if (plainIdMatches) {
+                plainIdMatches.forEach(match => {
+                    violations.push(`${path.relative(targetDir, f)}: Potential Branded Types violation (plain identifier '${match.trim()}' found inside interface).`);
+                });
+            }
+        }
+    });
+    if (violations.length === 0) {
+        console.warn("[OK] All systems compliant with ATABEY.md.");
+    }
+    else {
+        violations.forEach(v => console.warn(`[ERROR] ${v}`));
+    }
+}

package/framework-mcp/dist/src/cli/commands/contract.js

@@ -0,0 +1,50 @@
+import path from "path";
+import fs from "fs";
+import { getConfiguredPaths } from "../utils/memory.js";
+import { computeTypesHash, writeJsonFile } from "../utils/fs.js";
+import { ValidationError } from "../../shared/errors.js";
+/**
+ * Verify type safety between backend and frontend contracts.
+ */
+export async function verifyApiContractCommand(options = {}) {
+    const projectRoot = process.cwd();
+    const pathsMap = getConfiguredPaths();
+    const sharedDir = path.join(projectRoot, pathsMap.backend, "src/types");
+    const contractPath = path.join(projectRoot, pathsMap.backend, "contract.version.json");
+    if (!fs.existsSync(sharedDir) || !fs.existsSync(contractPath)) {
+        if (options.silent)
+            return false;
+        throw new ValidationError("API types or contract version file missing.", null, "Ensure you have initialized the project and the backend directory is correctly configured in config.json.");
+    }
+    const currentHash = computeTypesHash(projectRoot, sharedDir);
+    const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+    if (contract.contract_hash === currentHash) {
+        if (!options.silent)
+            console.warn("[OK] Contract is valid and synchronized.");
+        return true;
+    }
+    else {
+        if (options.silent)
+            return false;
+        throw new ValidationError("Contract drift detected!", { stored: contract.contract_hash, actual: currentHash }, "Run 'npx atabey update-contract' to re-synchronize the API contracts.");
+    }
+}
+/**
+ * Update and synchronize type safety between backend and frontend contracts.
+ */
+export async function updateApiContractCommand() {
+    const projectRoot = process.cwd();
+    const pathsMap = getConfiguredPaths();
+    const sharedDir = path.join(projectRoot, pathsMap.backend, "src/types");
+    const contractPath = path.join(projectRoot, pathsMap.backend, "contract.version.json");
+    if (!fs.existsSync(sharedDir)) {
+        throw new ValidationError("API types directory missing.", null, "The directory specified for backend types does not exist. Check your framework configuration.");
+    }
+    const currentHash = computeTypesHash(projectRoot, sharedDir);
+    const contractData = {
+        contract_hash: currentHash,
+        last_updated: new Date().toISOString()
+    };
+    writeJsonFile(contractPath, contractData);
+    console.warn(`[OK] Contract successfully synchronized. New hash: ${currentHash}`);
+}

package/framework-mcp/dist/src/cli/commands/dashboard.js

@@ -0,0 +1,123 @@
+import http from "http";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getFrameworkDir } from "../utils/memory.js";
+import { UI } from "../utils/ui.js";
+import { FRAMEWORK } from "../../shared/constants.js";
+/**
+ * Serves a JSON file.
+ */
+function serveJson(res, filePath) {
+    if (fs.existsSync(filePath)) {
+        try {
+            const content = fs.readFileSync(filePath, "utf8");
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(content);
+        }
+        catch (e) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: "Read Error", message: e.message }));
+        }
+    }
+    else {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: "Not Found", path: filePath }));
+    }
+}
+/**
+ * Serves a file with specific content type.
+ */
+function serveFile(res, filePath, contentType) {
+    if (fs.existsSync(filePath)) {
+        try {
+            const content = fs.readFileSync(filePath);
+            res.writeHead(200, { "Content-Type": contentType });
+            res.end(content);
+        }
+        catch (e) {
+            res.writeHead(500);
+            res.end(e.message);
+        }
+    }
+    else {
+        res.writeHead(404);
+        res.end("Not Found");
+    }
+}
+/**
+ * 🖥️ Hermes Visual Control Plane (Dashboard Server)
+ * Serves the framework state as a JSON API and the bundled Web UI.
+ */
+export async function dashboardCommand(port = FRAMEWORK.DASHBOARD_PORT) {
+    const frameworkDir = getFrameworkDir();
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const projectRoot = path.resolve(__dirname, "../../../");
+    const uiDistPath = path.join(projectRoot, "dist/ui");
+    const server = http.createServer((req, res) => {
+        // CORS Headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = req.url || "/";
+        // API Routes
+        if (url === "/api/status") {
+            const statusPath = path.join(frameworkDir, "memory", "status.json");
+            serveJson(res, statusPath);
+            return;
+        }
+        if (url === "/api/memory") {
+            const memoryPath = path.join(frameworkDir, "memory", "PROJECT_MEMORY.md");
+            serveFile(res, memoryPath, "text/markdown");
+            return;
+        }
+        if (url.startsWith("/api/logs/")) {
+            const agent = url.replace("/api/logs/", "");
+            const logPath = path.join(frameworkDir, "logs", `${agent}.json`);
+            serveJson(res, logPath);
+            return;
+        }
+        if (url === "/api/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "healthy", version: "0.0.6", frameworkDir }));
+            return;
+        }
+        // Static UI Serving
+        let filePath = path.join(uiDistPath, url === "/" ? "index.html" : url);
+        // Fallback to index.html for SPA routing if file not found
+        if (!fs.existsSync(filePath) && !url.startsWith("/api")) {
+            filePath = path.join(uiDistPath, "index.html");
+        }
+        if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()) {
+            const ext = path.extname(filePath).toLowerCase();
+            const mimeTypes = {
+                ".html": "text/html",
+                ".js": "application/javascript",
+                ".css": "text/css",
+                ".json": "application/json",
+                ".png": "image/png",
+                ".jpg": "image/jpg",
+                ".gif": "image/gif",
+                ".svg": "image/svg+xml",
+                ".ico": "image/x-icon",
+            };
+            const contentType = mimeTypes[ext] || "application/octet-stream";
+            serveFile(res, filePath, contentType);
+        }
+        else {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not Found", message: "Route not found" }));
+        }
+    });
+    server.listen(port, () => {
+        UI.success("\n[START] Hermes Visual Control Plane is running!");
+        UI.success(`[INFO] Web UI:    http://localhost:${port}`);
+        UI.success(`[DATA] API Base:  http://localhost:${port}/api`);
+        UI.warning("\n(Press Ctrl+C to stop the server)\n");
+    });
+}

package/framework-mcp/dist/src/cli/commands/explorer.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import { collectFiles } from "../utils/fs.js";
+const targetDir = process.cwd();
+export async function explorerGraphCommand(targetPath) {
+    console.warn(`🗺️  Generating Dependency Graph for: ${targetPath}...`);
+    const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx"]);
+    const edges = [];
+    files.forEach((f) => {
+        const content = fs.readFileSync(f, "utf8");
+        const name = path.basename(f, path.extname(f));
+        const imports = content.match(/from\s+['"]\.\.?\/[^'"]+['"]/g) || [];
+        imports.forEach((imp) => {
+            const target = path.basename(imp.split(/['"]/)[1]);
+            edges.push(`${name} --> ${target}`);
+        });
+    });
+    if (edges.length === 0) {
+        console.warn("ℹ️ No internal dependencies found.");
+    }
+    else {
+        console.warn("```mermaid\ngraph TD\n" + Array.from(new Set(edges)).join("\n") + "\n```");
+    }
+}
+export async function explorerAuditCommand(targetPath) {
+    console.warn(`[MEMORY] Codebase Intelligence Scan: ${targetPath}...`);
+    const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx"]);
+    const complexity = [];
+    files.forEach((f) => {
+        const content = fs.readFileSync(f, "utf8");
+        const lines = content.split("\n").length;
+        if (lines > 300)
+            complexity.push(`${path.relative(targetDir, f)} (${lines} lines)`);
+    });
+    if (complexity.length > 0) {
+        console.warn("\n[WARN] Complexity Spikes:");
+        complexity.forEach((c) => console.warn(`- ${c}`));
+    }
+    else {
+        console.warn("[OK] Codebase structure looks clean.");
+    }
+}

package/framework-mcp/dist/src/cli/commands/git.js

@@ -0,0 +1,40 @@
+import cp from "child_process";
+import path from "path";
+import { getConfiguredPaths } from "../utils/memory.js";
+export async function gitCommitCommand(traceId) {
+    try {
+        const diff = cp.execSync("git diff --staged", { encoding: "utf8" });
+        if (!diff) {
+            console.warn("ℹ️ No staged changes found. Use 'git add' first.");
+            return;
+        }
+        const files = cp.execSync("git diff --staged --name-only", { encoding: "utf8" })
+            .split("\n")
+            .filter(Boolean);
+        const pathsMap = getConfiguredPaths();
+        const backendTypesPath = path.join(pathsMap.backend, "src/types");
+        let type = "feat";
+        const scope = "code";
+        if (files.some((f) => f.includes(".md")))
+            type = "docs";
+        else if (files.some((f) => f.includes(backendTypesPath)))
+            type = "arch";
+        else if (files.some((f) => f.includes("bin/cli.js")))
+            type = "fix";
+        const summary = files.length === 1 ? `update ${path.basename(files[0])}` : `update ${files.length} files`;
+        console.warn(`\n### SUGGESTED COMMIT MESSAGE ###\n\n[${traceId}] ${type}(${scope}): ${summary}\n`);
+    }
+    catch {
+        console.warn("[ERROR] Git command failed.");
+    }
+}
+export async function gitSyncCommand() {
+    console.warn("🔄 Syncing with remote repository...");
+    try {
+        cp.execSync("git pull origin main --rebase", { stdio: "inherit" });
+        console.warn("[OK] Successfully synced and rebased.");
+    }
+    catch {
+        console.warn("[ERROR] Sync failed. Please resolve conflicts manually.");
+    }
+}

package/framework-mcp/dist/src/cli/commands/init/create-agent.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+import { UI } from "../../utils/ui.js";
+import { writeTextFile } from "../../../shared/fs.js";
+/**
+ * Plugin SDK: Creates a new custom agent template.
+ */
+export async function createAgentCommand(name) {
+    const projectRoot = process.cwd();
+    const agentsDir = path.join(projectRoot, "src/modules/agents/registry");
+    if (!fs.existsSync(agentsDir)) {
+        UI.error("Ajan kayıt dizini bulunamadı. Lütfen Atabey geliştirme ortamında olduğunuzdan emin olun.");
+        return;
+    }
+    const filePath = path.join(agentsDir, `${name}.ts`);
+    if (fs.existsSync(filePath)) {
+        UI.error(`Ajan '${name}' zaten mevcut.`);
+        return;
+    }
+    const template = `import { AgentDefinition } from "../types.js";
+
+const STATE_MACHINE = "../schema/agent-lifecycle-schema.json" as const;
+
+export const ${name}: AgentDefinition = {
+    name: "${name}",
+    displayName: "${name.charAt(0).toUpperCase() + name.slice(1)} Specialist",
+    role: "Custom Specialty",
+    description: "Automatically generated custom agent for specific project needs.",
+    capability: 7,
+    tier: "core",
+    tags: ["custom"],
+    stateMachine: STATE_MACHINE,
+    tools: [
+        "read_file",
+        "write_file",
+        "replace_text",
+        "grep_search",
+        "send_agent_message",
+    ],
+    instructions: {
+        identity: "${name.toUpperCase()} Domain Expert",
+        mission: "Execute tasks related to ${name} with high precision and following Atabey standards.",
+        chainOfThought: "1. Analyze Task\\n2. Plan Steps\\n3. Execute\\n4. Verify",
+        rules: [
+            "Always maintain type safety.",
+            "Log all critical actions.",
+        ],
+        knowledgeFiles: [],
+    },
+    specialties: {
+        ${name}: 10,
+    },
+};
+`;
+    writeTextFile(filePath, template);
+    UI.success(`[OK] New agent '${name}' created at src/modules/agents/registry/${name}.ts`);
+    UI.warning("[INFO] Don't forget to register the agent in src/modules/agents/definitions.ts");
+}

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

@@ -0,0 +1,112 @@
+import fs from "fs";
+import path from "path";
+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 } 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, frameworkDir, adapterId, dryRun, language = "tr") {
+    if (dryRun)
+        return;
+    const t = TRANSLATIONS[language];
+    let content = `# [ATABEY] ${t.constitution_title}\n\nDiscipline and Order.`;
+    let readSuccess = false;
+    try {
+        const templatePath = path.join(getPackageRoot(), "ATABEY.md");
+        if (fs.existsSync(templatePath)) {
+            content = fs.readFileSync(templatePath, "utf8");
+            readSuccess = true;
+        }
+    }
+    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(`[OK] Constitution file created inside: ${frameworkDir}/ATABEY.md${readSuccess ? "" : " (default template)"}`);
+}
+export function scaffoldFrameworkConfigs(targetDir, fDir, adapter, dryRun, selectedPalette, options) {
+    if (dryRun)
+        return;
+    const frameworkDir = path.join(targetDir, fDir);
+    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,
+            colors: palette
+        }
+    };
+    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 });
+    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)",
+                options?.frontendFramework || "Vite (React)"
+            ],
+            language: language,
+            policies: []
+        }, dryRun);
+    }
+    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 = {};
+    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 });
+    writeJsonFile(statusJsonPath, initialStatusJson, dryRun);
+}
+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] || 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);
+            if (isSelectedAdapter) {
+                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/framework-mcp/dist/src/cli/commands/init/scaffold-ops.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+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, dryRun) {
+    if (dryRun)
+        return;
+    // Scaffold Prompt Recipes
+    const promptsPath = path.join(frameworkDir, "prompts");
+    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" },
+        { file: "new-feature-recipe.md", template: "templates/prompts/new-feature-recipe.md" },
+        { file: "security-audit-recipe.md", template: "templates/prompts/security-audit-recipe.md" },
+        { file: "db-management-recipe.md", template: "templates/prompts/db-management-recipe.md" },
+        { file: "performance-optimization-recipe.md", template: "templates/prompts/performance-optimization-recipe.md" },
+        { 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);
+            if (fs.existsSync(fullTemplatePath)) {
+                const content = fs.readFileSync(fullTemplatePath, "utf8");
+                writeTextFile(path.join(promptsPath, recipe.file), content);
+            }
+        }
+        catch (e) {
+            logger.debug(`Failed to scaffold prompt recipe: ${recipe.file}`, e);
+        }
+    }
+    // Scaffold cli-commands.json
+    const cliCommands = {
+        commands: {
+            init: { agent: "manager", description: "Initialize Agent Atabey structure and AI configuration." },
+            check: { agent: "quality", description: "Verify framework files and code quality discipline." },
+            status: { agent: "manager", description: "Show the current status of the active project phase." },
+            "trace:new": { agent: "manager", description: "Generate a new Trace ID to start a task sequence." },
+            orchestrate: { agent: "manager", description: "Execute the Hermes message broker loop." },
+            "verify-contract": { agent: "architect", description: "Validate type contracts between backend and frontend." },
+            "update-contract": { agent: "architect", description: "Update the contract signature hash." }
+        }
+    };
+    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"), "# [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"), "# [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"), "# [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 });
+    writeTextFile(path.join(rulesDir, "global_rules.mdc"), `---
+description: Global Rules for Agent Atabey Army
+globs: **/*
+---
+
+# [ATABEY] Agent Atabey — Global Army Rules
+`);
+}