atabey 0.0.11 → 0.0.13

package/framework-mcp/dist/framework-mcp/src/utils/storage.js

@@ -0,0 +1,207 @@
+import Database from "better-sqlite3";
+import path from "path";
+import fs from "fs";
+import { getFrameworkDir } from "./memory.js";
+/**
+ * [DB] Atabey Storage Engine
+ * Central SQLite database for enterprise-scale agent state management.
+ */
+export class Storage {
+    static db = null;
+    static getDB() {
+        if (!this.db) {
+            const frameworkDir = getFrameworkDir();
+            if (!fs.existsSync(frameworkDir)) {
+                fs.mkdirSync(frameworkDir, { recursive: true });
+            }
+            const dbPath = path.join(frameworkDir, "atabey.db");
+            this.db = new Database(dbPath);
+            this.initializeSchema();
+        }
+        return this.db;
+    }
+    static initializeSchema() {
+        const db = this.db;
+        // Agents Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS agents (
+                name TEXT PRIMARY KEY,
+                state TEXT DEFAULT 'READY',
+                task TEXT DEFAULT 'Idle',
+                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        // Messages (Hermes) Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                sender TEXT,
+                receiver TEXT,
+                category TEXT,
+                content TEXT,
+                trace_id TEXT,
+                parent_id TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                requires_approval BOOLEAN DEFAULT 0
+            )
+        `);
+        // Tasks Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS tasks (
+                id TEXT PRIMARY KEY,
+                trace_id TEXT,
+                description TEXT,
+                agent TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                dependencies TEXT, -- JSON Array
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        // Logs Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                agent TEXT,
+                action TEXT,
+                trace_id TEXT,
+                status TEXT,
+                summary TEXT,
+                findings TEXT
+            )
+        `);
+        // Metadata (State) Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS metadata (
+                key TEXT PRIMARY KEY,
+                value TEXT
+            )
+        `);
+    }
+    // --- Agent Operations ---
+    static updateAgentStatus(name, state, task, lastUpdated) {
+        const db = this.getDB();
+        const cleanName = name.replace("@", "");
+        const timestamp = lastUpdated || new Date().toISOString();
+        db.prepare(`
+            INSERT INTO agents (name, state, task, last_updated) 
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET 
+                state = excluded.state,
+                task = excluded.task,
+                last_updated = excluded.last_updated
+        `).run(cleanName, state, task, timestamp);
+    }
+    static getAllAgents() {
+        return this.getDB().prepare("SELECT * FROM agents").all();
+    }
+    // --- Message Operations ---
+    static saveMessage(msg) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT INTO messages (sender, receiver, category, content, trace_id, parent_id, status, priority, requires_approval)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(msg.from, msg.to, msg.category, msg.content, msg.traceId, msg.parentId || null, msg.status || "PENDING", msg.priority || "NORMAL", msg.requiresApproval ? 1 : 0);
+    }
+    static getPendingMessages() {
+        const rows = this.getDB().prepare("SELECT * FROM messages WHERE status IN ('PENDING', 'APPROVED') ORDER BY priority DESC, timestamp ASC").all();
+        return rows.map(r => ({
+            id: r.id,
+            timestamp: r.timestamp,
+            from: r.sender,
+            to: r.receiver,
+            category: r.category,
+            content: r.content,
+            traceId: r.trace_id,
+            parentId: r.parent_id || undefined,
+            status: r.status,
+            priority: r.priority,
+            requiresApproval: r.requires_approval === 1
+        }));
+    }
+    static updateMessageStatus(id, status) {
+        this.getDB().prepare("UPDATE messages SET status = ? WHERE id = ?").run(status, id);
+    }
+    // --- Task Operations ---
+    static saveTask(task) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT INTO tasks (id, trace_id, description, agent, status, priority, dependencies)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                status = excluded.status,
+                description = excluded.description
+        `).run(task.id, task.traceId, task.description, task.agent, task.status, task.priority, JSON.stringify(task.dependencies || []));
+    }
+    static getTasks(traceId) {
+        const db = this.getDB();
+        let rows;
+        if (traceId) {
+            rows = db.prepare("SELECT * FROM tasks WHERE trace_id = ?").all(traceId);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM tasks").all();
+        }
+        return rows.map(r => {
+            let deps = [];
+            try {
+                const parsed = JSON.parse(r.dependencies || "[]");
+                // Handle cases where dependencies might be double-stringified or are raw JSON strings
+                deps = Array.isArray(parsed) ? parsed : JSON.parse(parsed);
+            }
+            catch {
+                // Keep empty array
+            }
+            return {
+                id: r.id,
+                traceId: r.trace_id,
+                description: r.description,
+                agent: r.agent,
+                status: r.status,
+                priority: r.priority,
+                dependencies: deps
+            };
+        });
+    }
+    static getLogs(agentName) {
+        const db = this.getDB();
+        let rows;
+        const cleanName = agentName ? agentName.replace("@", "") : undefined;
+        if (cleanName) {
+            rows = db.prepare("SELECT * FROM logs WHERE agent = ? ORDER BY timestamp DESC").all(cleanName);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM logs ORDER BY timestamp DESC").all();
+        }
+        return rows.map(r => ({
+            id: r.id,
+            timestamp: r.timestamp,
+            agent: r.agent,
+            action: r.action,
+            trace_id: r.trace_id || undefined,
+            status: r.status,
+            summary: r.summary,
+            findings: r.findings || undefined
+        }));
+    }
+    // --- Metadata Operations ---
+    static setMetadata(key, value) {
+        this.getDB().prepare(`
+            INSERT INTO metadata (key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        `).run(key, value);
+    }
+    static getMetadata(key) {
+        const row = this.getDB().prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+        return row ? row.value : null;
+    }
+    static reset() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}

package/framework-mcp/dist/framework-mcp/src/utils/types.js

@@ -0,0 +1,16 @@
+/**
+ * Agent Atabey Framework — Internal Branded Types
+ * Used to enforce absolute type safety within the core orchestration logic.
+ */
+/**
+ * Casts a raw string to a Branded Type.
+ * Use this only at the boundaries of the system.
+ */
+export function asTraceID(val) { return val; }
+export function asAgentID(val) { return val; }
+export function asPhaseID(val) { return val; }
+export function asProjectPath(val) { return val; }
+export function asMessageID(val) { return val; }
+export function asTaskID(val) { return val; }
+export function asLogID(val) { return val; }
+export function asPlanID(val) { return val; }

package/framework-mcp/dist/framework-mcp/src/utils/zod-to-mcp.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+/**
+ * A surgical converter to transform Zod schemas into MCP-compliant JSON schemas.
+ * This ensures "Single Source of Truth" and eliminates Type Drift.
+ */
+export function zodToMcpSchema(schema) {
+    const jsonSchema = {
+        type: "object",
+        properties: {}
+    };
+    const requiredKeys = [];
+    const shape = schema.shape;
+    for (const key in shape) {
+        const field = shape[key];
+        const { type, properties, required } = parseZodField(field);
+        jsonSchema.properties[key] = {
+            type,
+            ...(properties || {})
+        };
+        if (required) {
+            requiredKeys.push(key);
+        }
+    }
+    if (requiredKeys.length > 0) {
+        jsonSchema.required = requiredKeys;
+    }
+    return jsonSchema;
+}
+function parseZodField(field) {
+    let type = "string";
+    const properties = {};
+    const isRequired = !field.isOptional() && !field.isNullable();
+    let unwrapped = field;
+    // Handle Optional/Nullable
+    while (unwrapped instanceof z.ZodOptional || unwrapped instanceof z.ZodNullable || unwrapped instanceof z.ZodDefault) {
+        if (unwrapped instanceof z.ZodDefault) {
+            properties.default = unwrapped._def.defaultValue();
+        }
+        unwrapped = unwrapped._def.innerType;
+    }
+    // Handle Branded Types
+    if (unwrapped instanceof z.ZodBranded) {
+        unwrapped = unwrapped._def.type;
+    }
+    if (unwrapped instanceof z.ZodString) {
+        type = "string";
+        const checks = unwrapped._def.checks;
+        for (const check of checks) {
+            if (check.kind === "regex")
+                properties.pattern = check.regex.source;
+            if (check.kind === "min")
+                properties.minLength = check.value;
+        }
+    }
+    else if (unwrapped instanceof z.ZodNumber) {
+        type = "number";
+    }
+    else if (unwrapped instanceof z.ZodBoolean) {
+        type = "boolean";
+    }
+    else if (unwrapped instanceof z.ZodEnum) {
+        type = "string";
+        properties.enum = unwrapped._def.values;
+    }
+    else if (unwrapped instanceof z.ZodArray) {
+        type = "array";
+        const itemType = parseZodField(unwrapped._def.type);
+        properties.items = { type: itemType.type, ...(itemType.properties || {}) };
+    }
+    else if (unwrapped instanceof z.ZodObject) {
+        type = "object";
+        const nested = zodToMcpSchema(unwrapped);
+        properties.properties = nested.properties;
+        if (nested.required) {
+            properties.required = nested.required;
+        }
+    }
+    return { type, properties, required: isRequired };
+}

package/framework-mcp/dist/index.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { TOOLS, toolHandlers } from "./tools/index.js";
+import { TOOLS, toolHandlers, toolSchemas } from "./tools/index.js";
 import { RESOURCES, handleReadResource } from "./resources/index.js";
 // ─── Server Setup ─────────────────────────────────────────────────
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -32,8 +32,20 @@ const server = new Server({
         resources: {},
     },
 });
-// Basic Schema Validator for Required Fields
+/**
+ * Validates tool arguments using Zod schemas for "Zero Type Hole" compliance.
+ * Falls back to basic presence check if no Zod schema is defined for the tool.
+ */
 function validateArgs(toolName, args) {
+    const schema = toolSchemas[toolName];
+    if (schema) {
+        const result = schema.safeParse(args);
+        if (!result.success) {
+            return result.error.errors.map(e => `${e.path.join(".")}: ${e.message}`).join(", ");
+        }
+        return null;
+    }
+    // Fallback for tools without Zod schemas yet
     const definition = TOOLS.find(t => t.name === toolName);
     if (!definition)
         return `Unknown tool: ${toolName}`;

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

@@ -0,0 +1,279 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { VectorStore } from "../../modules/memory/vector-store.js";
+import { FRAMEWORK, FRAMEWORK_DIR_CANDIDATES, MCP, } from "../../shared/constants.js";
+import { ensureDir, writeJsonFile, writeTextFile } from "../../shared/fs.js";
+import { logger } from "../../shared/logger.js";
+import { Storage } from "../../shared/storage.js";
+export { generateULID } from "./time.js";
+const CWD = process.cwd();
+const HOME = os.homedir();
+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;
+            }
+        }
+    }
+    catch (err) {
+        logger.debug("Failed to read package.json in findFrameworkDir", err);
+    }
+    return null;
+}
+export function isFrameworkDevelopmentRepo() {
+    try {
+        const pkgPath = path.join(CWD, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (pkg.name === "atabey") {
+                return true;
+            }
+        }
+    }
+    catch (err) {
+        logger.debug("Failed to read package.json in isFrameworkDevelopmentRepo", err);
+    }
+    return false;
+}
+export function getLocalFrameworkDir() {
+    const localDir = findFrameworkDir(CWD);
+    return localDir || path.join(CWD, FRAMEWORK.CORE_DIR);
+}
+export function getConfigDir() {
+    const localDir = findFrameworkDir(CWD);
+    if (localDir)
+        return localDir;
+    // Check for standard local directories if package.json doesn't specify
+    const localCandidates = [...FRAMEWORK_DIR_CANDIDATES, ".agent"];
+    for (const cand of localCandidates) {
+        const p = path.join(CWD, cand);
+        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() {
+    const testDir = process.env[MCP.TEST_DIR_ENV];
+    if (testDir)
+        return testDir;
+    return getConfigDir();
+}
+export function getDocumentStorePath() {
+    const frameworkDir = getFrameworkDir();
+    return path.join(frameworkDir, "memory");
+}
+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" });
+    }
+    const statusFile = path.join(storePath, "status.json");
+    if (!fs.existsSync(statusFile)) {
+        writeJsonFile(statusFile, {});
+    }
+    // Initialize SQLite
+    Storage.setMetadata("phase", "PHASE_0");
+    Storage.setMetadata("traceId", "T-000");
+    Storage.setMetadata("managerState", "ACTIVE");
+    // Initialize Vector Memory for semantic search
+    VectorStore.initialize();
+    // Ensure the initial Markdown view is created
+    syncMarkdownMemory(frameworkDir);
+}
+export function readState() {
+    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 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() {
+    return Storage.getTasks();
+}
+export function getMemoryPath() {
+    return path.join(getDocumentStorePath(), "state.json");
+}
+export function readActiveTraceId(memoryContent) {
+    try {
+        const state = JSON.parse(memoryContent);
+        return state.traceId || null;
+    }
+    catch (_e) { /* ignore */
+        return null;
+    }
+}
+export function updateProjectMemory(section, content) {
+    if (section === "HISTORY") {
+        updateDocumentStore("history", { content }, new Date().toISOString().replace(/[:.]/g, "-"));
+    }
+    else {
+        const state = readState() || {};
+        state[section] = content;
+        updateDocumentStore("state", state);
+    }
+}
+export function initializeMemory(memoryPathOrBase, targetBaseOrDryRun) {
+    const targetBase = typeof targetBaseOrDryRun === "string" ? targetBaseOrDryRun : memoryPathOrBase;
+    initDocumentStore(targetBase);
+    logger.info("[OK] Document store initialized.");
+}
+export function getConfiguredPaths() {
+    const defaultPaths = { backend: "apps/backend", frontend: "apps/web", mobile: "apps/mobile", docs: "docs", tests: "tests" };
+    try {
+        const frameworkDir = getConfigDir();
+        const configPath = path.join(frameworkDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return rawConfig.paths || defaultPaths;
+        }
+    }
+    catch (err) {
+        logger.debug("Critical config read failure", err);
+    }
+    return defaultPaths;
+}
+export function updateDocumentStore(type, data, id, frameworkDir) {
+    const storePath = frameworkDir ? path.join(frameworkDir, "memory") : getDocumentStorePath();
+    ensureDir(storePath);
+    switch (type) {
+        case "state":
+            writeJsonFile(path.join(storePath, "state.json"), data);
+            break;
+        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": {
+            Storage.saveTask(data);
+            break;
+        }
+        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) {
+    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 = Storage.getTasks();
+        if (!state)
+            return;
+        const lines = [
+            "# [MEMORY] Agent Atabey — Project Memory",
+            "",
+            "## [STATE] 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]) => {
+            if (!internalFields.includes(key) && value) {
+                lines.push("", `## [INFO] ${key}`, String(value));
+            }
+        });
+        lines.push("", "## [TASKS] 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("", "## [AI] Agent Statuses");
+        lines.push("| Agent | State | Active Task | Last Updated |");
+        lines.push("| :--- | :--- | :--- | :--- |");
+        for (const [agent, info] of Object.entries(status)) {
+            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)) {
+            const histFiles = fs.readdirSync(historyDir)
+                .filter(f => f.endsWith(".json"))
+                .sort()
+                .reverse()
+                .slice(0, 10);
+            histFiles.forEach(f => {
+                const hist = JSON.parse(fs.readFileSync(path.join(historyDir, f), "utf8"));
+                lines.push(`### ${f.replace(".json", "")}`);
+                lines.push(hist.content);
+                lines.push("");
+            });
+        }
+        writeTextFile(mdPath, lines.join("\n"));
+        logger.debug("Markdown memory synchronized.");
+    }
+    catch (err) {
+        logger.debug("Markdown memory sync failed", err);
+    }
+}
+export function acquireMemoryLock(lockPath) {
+    try {
+        fs.writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
+        return true;
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "EEXIST") {
+            try {
+                const stat = fs.statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > 10000) {
+                    fs.unlinkSync(lockPath);
+                    fs.writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
+                    return true;
+                }
+            }
+            catch (_e) { /* ignore */
+                // Ignore
+            }
+        }
+        return false;
+    }
+}
+export function releaseMemoryLock(lockPath) {
+    if (fs.existsSync(lockPath))
+        fs.unlinkSync(lockPath);
+}

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

@@ -0,0 +1,27 @@
+export function generateULID(seedTime = Date.now(), seed) {
+    const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    const ENCODING_LEN = ENCODING.length;
+    let time = seedTime;
+    const timeChars = new Array(10);
+    for (let i = 9; i >= 0; i--) {
+        timeChars[i] = ENCODING.charAt(time % ENCODING_LEN);
+        time = Math.floor(time / ENCODING_LEN);
+    }
+    const randomChars = new Array(16);
+    if (seed) {
+        let pseudoRandom = seed;
+        for (let i = 0; i < 16; i++) {
+            pseudoRandom = (pseudoRandom * 16807) % 2147483647;
+            randomChars[i] = ENCODING.charAt(pseudoRandom % ENCODING_LEN);
+        }
+    }
+    else {
+        for (let i = 0; i < 16; i++) {
+            randomChars[i] = ENCODING.charAt(Math.floor(Math.random() * ENCODING_LEN));
+        }
+    }
+    return timeChars.join("") + randomChars.join("");
+}
+export function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}