atabey 0.0.6 → 0.0.8

package/{src/cli/utils/config-schema.ts → framework-mcp/dist/src/cli/utils/config-schema.js}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 /**
  * Standard Color Palette Schema
  */
@@ -8,7 +7,6 @@ export const ColorPaletteSchema = z.object({
     secondary: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
     accent: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
 });
-
 /**
  * Agent Atabey config.json Schema
  */
@@ -32,7 +30,6 @@ export const ConfigSchema = z.object({
         tests: "tests"
     })
 });
-
 /**
  * MCP mcp.json Schema
  */
@@ -43,6 +40,3 @@ export const McpConfigSchema = z.object({
         env: z.record(z.string()).optional()
     }))
 });
-
-export type AtabeyConfig = z.infer<typeof ConfigSchema>;
-export type McpConfig = z.infer<typeof McpConfigSchema>;

package/{src/cli/utils/fs.ts → framework-mcp/dist/src/cli/utils/fs.js}

@@ -1,14 +1,10 @@
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
-
 import { remapFrameworkContent } from "../adapters/index.js"; // Import from the new adapters.js
-import type { AdapterId } from "../adapters/index.js";
 import { ensureDir, writeTextFile, writeJsonFile, appendFile } from "../../shared/fs.js";
-
 export { ensureDir, writeTextFile, writeJsonFile, appendFile };
-
-export function updateGitIgnore(targetPath: string, frameworkDir = ".atabey", dryRun = false): void {
+export function updateGitIgnore(targetPath, frameworkDir = ".atabey", dryRun = false) {
     const IGNORE_LINES = [
         "# Agent Atabey",
         `${frameworkDir}/logs/*.json`,
@@ -17,60 +13,38 @@ export function updateGitIgnore(targetPath: string, frameworkDir = ".atabey", dr
         ".env",
         ".DS_Store",
     ];
-
     let content = "";
     if (fs.existsSync(targetPath)) {
         content = fs.readFileSync(targetPath, "utf8");
     }
-
     const lines = content.split("\n").map((l) => l.trim());
     let added = false;
-
     for (const line of IGNORE_LINES) {
         if (!lines.includes(line)) {
             content += (content.endsWith("\n") || content === "" ? "" : "\n") + line + "\n";
             added = true;
         }
     }
-
     if (added) {
         if (dryRun) {
             console.warn(`[DRY RUN] Would update .gitignore at ${targetPath}`);
-        } else {
+        }
+        else {
             writeTextFile(targetPath, content);
-            console.warn("✅ .gitignore updated.");
+            console.warn("[OK] .gitignore updated.");
         }
     }
 }
-
-
-interface SanitizeJsonFunction {
-  (obj: unknown, targetScope?: string): unknown;
-}
-
-export function copyDir(
-    src: string,
-    dest: string,
-    skipSet = new Set<string>(),
-    nonDestructive = false,
-    frameworkDir = ".gemini",
-    targetScope = "",
-    sanitizeJson: SanitizeJsonFunction,
-    adapterId: AdapterId = "gemini",
-    dryRun = false,
-): void {
+export function copyDir(src, dest, skipSet = new Set(), nonDestructive = false, frameworkDir = ".gemini", targetScope = "", sanitizeJson, adapterId = "gemini", dryRun = false) {
     const DEFAULT_SKIP = new Set(["node_modules", ".git", ".DS_Store", "package-lock.json"]);
     const actualSkip = new Set([...DEFAULT_SKIP, ...skipSet]);
-
     if (!fs.existsSync(dest) && !dryRun) {
         fs.mkdirSync(dest, { recursive: true });
     }
-
     fs.readdirSync(src, { withFileTypes: true }).forEach((entry) => {
-        if (actualSkip.has(entry.name)) return;
-
+        if (actualSkip.has(entry.name))
+            return;
         const srcPath = path.join(src, entry.name);
-        
         // Physical folder remapping during copy.
         // In unified mode (frameworkDir === ".atabey") folder names are always standard —
         // agents/ stays agents/, knowledge/ stays knowledge/.
@@ -78,66 +52,60 @@ export function copyDir(
         let effectiveEntryName = entry.name;
         if (entry.isDirectory() && frameworkDir !== ".atabey") {
             if (entry.name === "agents") {
-                if (adapterId === "antigravity-cli") effectiveEntryName = "skills";
-                else if (adapterId === "grok") effectiveEntryName = "plugins";
-            } else if (entry.name === "knowledge") {
-                if (adapterId === "antigravity-cli") effectiveEntryName = "rules";
+                if (adapterId === "antigravity-cli")
+                    effectiveEntryName = "skills";
+                else if (adapterId === "grok")
+                    effectiveEntryName = "plugins";
+            }
+            else if (entry.name === "knowledge") {
+                if (adapterId === "antigravity-cli")
+                    effectiveEntryName = "rules";
             }
         }
-        
         const destPath = path.join(dest, effectiveEntryName);
-
         if (entry.isDirectory()) {
-            copyDir(
-                srcPath,
-                destPath,
-                skipSet,
-                nonDestructive,
-                frameworkDir,
-                targetScope,
-                sanitizeJson,
-                adapterId,
-                dryRun,
-            );
-        } else {
+            copyDir(srcPath, destPath, skipSet, nonDestructive, frameworkDir, targetScope, sanitizeJson, adapterId, dryRun);
+        }
+        else {
             if (nonDestructive && fs.existsSync(destPath)) {
                 return;
             }
-
             const ext = path.extname(entry.name);
             const textExtensions = [".md", ".json", ".js", ".ts", ".txt", ""];
-
             if (textExtensions.includes(ext)) {
                 let content = fs.readFileSync(srcPath, "utf8");
                 content = remapFrameworkContent(content, frameworkDir, adapterId); // Use the new remap function
-
                 if (ext === ".json") {
                     try {
                         const json = JSON.parse(content);
                         writeJsonFile(destPath, sanitizeJson(json, targetScope), dryRun);
-                    } catch {
+                    }
+                    catch {
                         const fallback = content.replace(/workspace:[^"'\s]*/g, "*");
                         writeTextFile(destPath, fallback, dryRun);
                     }
-                } else {
+                }
+                else {
                     content = content.replace(/workspace:[^"'\s]*/g, "*");
                     content = remapFrameworkContent(content, frameworkDir, adapterId); // Apply remap once to the final content
                     writeTextFile(destPath, content, dryRun);
                 }
-            } else {
+            }
+            else {
                 if (dryRun) {
                     console.warn(`[DRY RUN] Would copy binary file: ${destPath}`);
-                } else {
+                }
+                else {
                     fs.copyFileSync(srcPath, destPath);
                 }
             }
         }
     });
 }
-
-export function collectFiles(dir: string, extensions: string[]): string[] {
-    let results: string[] = [];
-    if (!fs.existsSync(dir)) return results;
+export function collectFiles(dir, extensions) {
+    let results = [];
+    if (!fs.existsSync(dir))
+        return results;
     const list = fs.readdirSync(dir);
     list.forEach((file) => {
         file = path.join(dir, file);
@@ -146,19 +114,18 @@ export function collectFiles(dir: string, extensions: string[]): string[] {
             if (!file.includes("node_modules") && !file.includes(".git")) {
                 results = results.concat(collectFiles(file, extensions));
             }
-        } else if (extensions.includes(path.extname(file))) {
+        }
+        else if (extensions.includes(path.extname(file))) {
             results.push(file);
         }
     });
     return results;
 }
-
-export function computeTypesHash(projectRoot: string, sharedDir: string): string {
-    const walk = (d: string): string[] => fs.readdirSync(d, { withFileTypes: true }).flatMap((e) => {
+export function computeTypesHash(projectRoot, sharedDir) {
+    const walk = (d) => fs.readdirSync(d, { withFileTypes: true }).flatMap((e) => {
         const fullPath = path.join(d, e.name);
         return e.isDirectory() ? walk(fullPath) : (e.name.endsWith(".ts") ? [fullPath] : []);
     });
-
     const hash = crypto.createHash("sha256");
     for (const filePath of walk(sharedDir).sort()) {
         hash.update(path.relative(projectRoot, filePath));

package/{src/cli/utils/i18n.ts → framework-mcp/dist/src/cli/utils/i18n.js}

@@ -1,23 +1,8 @@
-export type SupportedLanguage = "tr" | "en";
-
-export interface Translations {
-    welcome: string;
-    select_backend: string;
-    select_language: string;
-    select_dirs: string;
-    select_agents: string;
-    select_palette: string;
-    init_success: string;
-    constitution_title: string;
-    status_title: string;
-    agent_ready: string;
-    next_steps: string;
-}
-
-export const TRANSLATIONS: Record<SupportedLanguage, Translations> = {
+export const TRANSLATIONS = {
     tr: {
         welcome: "Agent Atabey İnteraktif Kuruluma Hoş Geldiniz!",
         select_backend: "Kurumsal Backend Dilini Seçin",
+        select_frontend: "Kurumsal Frontend Altyapısını Seçin",
         select_language: "Framework İletişim Dilini Seçin",
         select_dirs: "Dahil edilecek framework dizinlerini seçin (örn: 1,2,3) veya HEPSİ için Enter:",
         select_agents: "Dahil edilecek çekirdek ajanları seçin (örn: 1,2) veya HEPSİ için Enter:",
@@ -31,6 +16,7 @@ export const TRANSLATIONS: Record<SupportedLanguage, Translations> = {
     en: {
         welcome: "Welcome to Agent Atabey Interactive Setup!",
         select_backend: "Select Enterprise Backend Language",
+        select_frontend: "Select Enterprise Frontend Framework/Build Tool",
         select_language: "Select Framework Communication Language",
         select_dirs: "Enter directory numbers to include (e.g. 1,2,3) or Enter for ALL:",
         select_agents: "Enter agent numbers to include (e.g. 1,2) or Enter for ALL:",

package/{src/cli/utils/memory.ts → framework-mcp/dist/src/cli/utils/memory.js}

@@ -3,36 +3,29 @@ import os from "os";
 import path from "path";
 import { logger } from "../../shared/logger.js";
 import { ensureDir, writeTextFile, writeJsonFile } from "../../shared/fs.js";
-import { StateSchema, AgentStatusSchema, TaskSchema } from "./schemas.js";
-import type { TraceID } from "../../shared/types.js";
-import {
-    FRAMEWORK,
-    FRAMEWORK_DIR_CANDIDATES,
-    MCP,
-} from "../../shared/constants.js";
-
+import { Storage } from "../../shared/storage.js";
+import { FRAMEWORK, FRAMEWORK_DIR_CANDIDATES, MCP, } from "../../shared/constants.js";
 export { generateULID } from "./time.js";
-
 const CWD = process.cwd();
 const HOME = os.homedir();
-
-function findFrameworkDir(basePath: string): string | null {
+function findFrameworkDir(basePath) {
     try {
         const pkgPath = path.join(basePath, "package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
             if (pkg.atabey && typeof pkg.atabey.frameworkDir === "string") {
                 const customDir = path.join(basePath, pkg.atabey.frameworkDir);
-                if (fs.existsSync(customDir)) return customDir;
+                if (fs.existsSync(customDir))
+                    return customDir;
             }
         }
-    } catch (err) {
+    }
+    catch (err) {
         logger.debug("Failed to read package.json in findFrameworkDir", err);
     }
     return null;
 }
-
-export function isFrameworkDevelopmentRepo(): boolean {
+export function isFrameworkDevelopmentRepo() {
     try {
         const pkgPath = path.join(CWD, "package.json");
         if (fs.existsSync(pkgPath)) {
@@ -41,53 +34,48 @@ export function isFrameworkDevelopmentRepo(): boolean {
                 return true;
             }
         }
-    } catch (err) {
+    }
+    catch (err) {
         logger.debug("Failed to read package.json in isFrameworkDevelopmentRepo", err);
     }
     return false;
 }
-
-export function getLocalFrameworkDir(): string {
+export function getLocalFrameworkDir() {
     const localDir = findFrameworkDir(CWD);
     return localDir || path.join(CWD, FRAMEWORK.CORE_DIR);
 }
-
-export function getConfigDir(): string {
+export function getConfigDir() {
     const localDir = findFrameworkDir(CWD);
-    if (localDir) return localDir;
-
+    if (localDir)
+        return localDir;
     // Check for standard local directories if package.json doesn't specify
-    const localCandidates = [...FRAMEWORK_DIR_CANDIDATES, ".agent"] as string[];
+    const localCandidates = [...FRAMEWORK_DIR_CANDIDATES, ".agent"];
     for (const cand of localCandidates) {
         const p = path.join(CWD, cand);
-        if (fs.existsSync(p)) return p;
+        if (fs.existsSync(p))
+            return p;
     }
-
     // In dev repo, don't fall back to global dir. Point to local default.
     if (isFrameworkDevelopmentRepo()) {
         return path.join(CWD, FRAMEWORK.CORE_DIR);
     }
-
     return path.join(HOME, FRAMEWORK.CORE_DIR);
 }
-
-export function getFrameworkDir(): string {
+export function getFrameworkDir() {
     const testDir = process.env[MCP.TEST_DIR_ENV];
-    if (testDir) return testDir;
+    if (testDir)
+        return testDir;
     return getConfigDir();
 }
-
 export function getDocumentStorePath() {
     const frameworkDir = getFrameworkDir();
     return path.join(frameworkDir, "memory");
 }
-
-export function initDocumentStore(frameworkDir?: string) {
+export function initDocumentStore(frameworkDir) {
     const storePath = frameworkDir ? path.join(frameworkDir, "memory") : getDocumentStorePath();
     ensureDir(storePath);
     ensureDir(path.join(storePath, "tasks"));
     ensureDir(path.join(storePath, "history"));
-    
     const stateFile = path.join(storePath, "state.json");
     if (!fs.existsSync(stateFile)) {
         writeJsonFile(stateFile, { phase: "PHASE_0", traceId: "T-000", managerState: "ACTIVE" });
@@ -96,62 +84,59 @@ export function initDocumentStore(frameworkDir?: string) {
     if (!fs.existsSync(statusFile)) {
         writeJsonFile(statusFile, {});
     }
-
+    // Initialize SQLite
+    Storage.setMetadata("phase", "PHASE_0");
+    Storage.setMetadata("traceId", "T-000");
+    Storage.setMetadata("managerState", "ACTIVE");
     // Ensure the initial Markdown view is created
     syncMarkdownMemory(frameworkDir);
 }
-
 export function readState() {
-    const statePath = path.join(getDocumentStorePath(), "state.json");
-    if (!fs.existsSync(statePath)) return null;
-    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+    const phase = Storage.getMetadata("phase") || "PHASE_0";
+    const traceId = Storage.getMetadata("traceId") || "T-000";
+    const managerState = Storage.getMetadata("managerState") || "ACTIVE";
+    return { phase, traceId, managerState };
 }
-
 export function readStatus() {
-    const statusPath = path.join(getDocumentStorePath(), "status.json");
-    if (!fs.existsSync(statusPath)) return {};
-    return JSON.parse(fs.readFileSync(statusPath, "utf8"));
+    const agents = Storage.getAllAgents();
+    const status = {};
+    agents.forEach((a) => {
+        const name = a.name.startsWith("@") ? a.name : `@${a.name}`;
+        status[name] = { state: a.state, task: a.task, lastUpdated: a.last_updated };
+    });
+    return status;
 }
-
 export function listTasks() {
-    const tasksPath = path.join(getDocumentStorePath(), "tasks");
-    if (!fs.existsSync(tasksPath)) return [];
-    
-    return fs.readdirSync(tasksPath)
-        .filter(f => f.endsWith(".json"))
-        .map(f => JSON.parse(fs.readFileSync(path.join(tasksPath, f), "utf8")));
+    return Storage.getTasks();
 }
-
-export function getMemoryPath(): string {
+export function getMemoryPath() {
     return path.join(getDocumentStorePath(), "state.json");
 }
-
-export function readActiveTraceId(memoryContent: string): string | null {
+export function readActiveTraceId(memoryContent) {
     try {
         const state = JSON.parse(memoryContent);
         return state.traceId || null;
-    } catch (_e) { /* ignore */
+    }
+    catch (_e) { /* ignore */
         return null;
     }
 }
-
-export function updateProjectMemory(section: string, content: string) {
+export function updateProjectMemory(section, content) {
     if (section === "HISTORY") {
         updateDocumentStore("history", { content }, new Date().toISOString().replace(/[:.]/g, "-"));
-    } else {
+    }
+    else {
         const state = readState() || {};
         state[section] = content;
         updateDocumentStore("state", state);
     }
 }
-
-export function initializeMemory(memoryPathOrBase: string, targetBaseOrDryRun?: string | boolean): void {
+export function initializeMemory(memoryPathOrBase, targetBaseOrDryRun) {
     const targetBase = typeof targetBaseOrDryRun === "string" ? targetBaseOrDryRun : memoryPathOrBase;
     initDocumentStore(targetBase);
-    logger.info("✅ Document store initialized.");
+    logger.info("[OK] Document store initialized.");
 }
-
-export function getConfiguredPaths(): { backend: string; frontend: string; mobile: string; docs: string; tests: string } {
+export function getConfiguredPaths() {
     const defaultPaths = { backend: "apps/backend", frontend: "apps/web", mobile: "apps/mobile", docs: "docs", tests: "tests" };
     try {
         const frameworkDir = getConfigDir();
@@ -160,65 +145,64 @@ export function getConfiguredPaths(): { backend: string; frontend: string; mobil
             const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
             return rawConfig.paths || defaultPaths;
         }
-    } catch (err) {
+    }
+    catch (err) {
         logger.debug("Critical config read failure", err);
     }
     return defaultPaths;
 }
-
-export function updateDocumentStore(type: "state" | "task" | "history" | "status", data: unknown, id?: string | TraceID, frameworkDir?: string) {
+export function updateDocumentStore(type, data, id, frameworkDir) {
     const storePath = frameworkDir ? path.join(frameworkDir, "memory") : getDocumentStorePath();
     ensureDir(storePath);
-
     switch (type) {
         case "state":
-            StateSchema.parse(data);
             writeJsonFile(path.join(storePath, "state.json"), data);
             break;
-        case "status":
-            AgentStatusSchema.parse(data);
-            writeJsonFile(path.join(storePath, "status.json"), data);
+        case "status": {
+            const status = data;
+            for (const [agent, info] of Object.entries(status)) {
+                Storage.updateAgentStatus(agent, info.state, info.task, info.lastUpdated);
+            }
             break;
-        case "task":
-            TaskSchema.parse(data);
-            ensureDir(path.join(storePath, "tasks"));
-            writeJsonFile(path.join(storePath, "tasks", `${id}.json`), data);
+        }
+        case "task": {
+            Storage.saveTask(data);
             break;
-        case "history":
-            ensureDir(path.join(storePath, "history"));
-            writeJsonFile(path.join(storePath, "history", `${id}.json`), data);
+        }
+        case "history": {
+            const db = Storage.getDB();
+            db.prepare(`
+                INSERT INTO logs (agent, action, summary)
+                VALUES (?, ?, ?)
+            `).run("@manager", "HISTORY_UPDATE", data.content);
             break;
+        }
     }
-
     // Auto-sync Markdown view after any change
     syncMarkdownMemory(frameworkDir);
 }
-
 /**
  * Single Source of Truth Bridge: JSON -> Markdown
  * Regenerates PROJECT_MEMORY.md from structured state.
  */
-export function syncMarkdownMemory(fDir?: string) {
+export function syncMarkdownMemory(fDir) {
     const frameworkDir = fDir || getFrameworkDir();
     const storePath = path.join(frameworkDir, "memory");
     const mdPath = path.join(storePath, "PROJECT_MEMORY.md");
-
     try {
         const state = readState();
         const status = readStatus();
-        const tasks = listTasks();
-
-        if (!state) return;
-
+        const tasks = Storage.getTasks();
+        if (!state)
+            return;
         const lines = [
-            "# 🧠 Agent Atabey — Project Memory",
+            "# [MEMORY] Agent Atabey — Project Memory",
             "",
             "## 📍 Current State",
             `- **Phase:** ${state.phase || "PHASE_0"}`,
             `- **Trace ID:** ${state.traceId || "N/A"}`,
             `- **@manager state:** ${state.managerState || "ACTIVE"}`,
         ];
-
         // Add custom sections from state
         const internalFields = ["phase", "traceId", "managerState"];
         Object.entries(state).forEach(([key, value]) => {
@@ -226,31 +210,21 @@ export function syncMarkdownMemory(fDir?: string) {
                 lines.push("", `## 📌 ${key}`, String(value));
             }
         });
-
-        lines.push(
-            "",
-            "## 📋 Active Tasks",
-            "| Trace ID | Task | Agent | Priority | Status |",
-            "| :--- | :--- | :--- | :--- | :--- |",
-        );
-
+        lines.push("", "## 📋 Active Tasks", "| Trace ID | Task | Agent | Priority | Status |", "| :--- | :--- | :--- | :--- | :--- |");
         tasks.forEach(t => {
             if (t.status !== "COMPLETED") {
                 lines.push(`| ${t.traceId} | ${t.description} | ${t.agent} | ${t.priority} | ${t.status} |`);
             }
         });
-
-        lines.push("", "## 🤖 Agent Statuses");
+        lines.push("", "## [AI] Agent Statuses");
         lines.push("| Agent | State | Active Task | Last Updated |");
         lines.push("| :--- | :--- | :--- | :--- |");
-
         for (const [agent, info] of Object.entries(status)) {
-            const data = info as { state: string; task: string; lastUpdated?: string };
-            lines.push(`| @${agent} | ${data.state} | ${data.task} | ${data.lastUpdated || "-"} |`);
+            const data = info;
+            const displayAgent = agent.startsWith("@") ? agent : `@${agent}`;
+            lines.push(`| ${displayAgent} | ${data.state} | ${data.task} | ${data.lastUpdated || "-"} |`);
         }
-
         lines.push("", "## 📜 HISTORY");
-        
         // Add last 5 history items
         const historyDir = path.join(storePath, "history");
         if (fs.existsSync(historyDir)) {
@@ -259,7 +233,6 @@ export function syncMarkdownMemory(fDir?: string) {
                 .sort()
                 .reverse()
                 .slice(0, 10);
-            
             histFiles.forEach(f => {
                 const hist = JSON.parse(fs.readFileSync(path.join(historyDir, f), "utf8"));
                 lines.push(`### ${f.replace(".json", "")}`);
@@ -267,21 +240,20 @@ export function syncMarkdownMemory(fDir?: string) {
                 lines.push("");
             });
         }
-
         writeTextFile(mdPath, lines.join("\n"));
         logger.debug("Markdown memory synchronized.");
-    } catch (err) {
+    }
+    catch (err) {
         logger.debug("Markdown memory sync failed", err);
     }
 }
-
-
-export function acquireMemoryLock(lockPath: string): boolean {
+export function acquireMemoryLock(lockPath) {
     try {
         fs.writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
         return true;
-    } catch (err: unknown) {
-        const error = err as { code?: string };
+    }
+    catch (err) {
+        const error = err;
         if (error.code === "EEXIST") {
             try {
                 const stat = fs.statSync(lockPath);
@@ -290,14 +262,15 @@ export function acquireMemoryLock(lockPath: string): boolean {
                     fs.writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
                     return true;
                 }
-            } catch (_e) { /* ignore */
+            }
+            catch (_e) { /* ignore */
                 // Ignore
             }
         }
         return false;
     }
 }
-
-export function releaseMemoryLock(lockPath: string): void {
-    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+export function releaseMemoryLock(lockPath) {
+    if (fs.existsSync(lockPath))
+        fs.unlinkSync(lockPath);
 }