atabey 0.0.14 → 0.0.15

package/framework-mcp/dist/framework-mcp/src/utils/silent-router.js

@@ -9,10 +9,11 @@
  *
  * Features:
  * - Auto-agent detection from tool call context
- * - Silent system prompt injection
+ * - Silent system prompt injection with specialty memory
  * - Multi-agent chain support
  * - Stealth notifications (stderr/dashboard only, never chat)
  */
+import { EvaluationEngine } from "../../../src/modules/engines/evaluation-engine.js";
 import { RoutingEngine } from "../../../src/modules/engines/routing-engine.js";
 // ─── Configuration ────────────────────────────────────────────────
 const CONFIG = {
@@ -22,6 +23,8 @@ const CONFIG = {
     STEALTH_NOTIFY: process.env.MCP_SILENT_STEALTH !== "false",
     /** Agent override via env (for testing/debugging) */
     FORCE_AGENT: process.env.MCP_FORCE_AGENT || null,
+    /** Enable specialty memory injection into context */
+    INJECT_SPECIALTY_MEMORY: process.env.MCP_INJECT_SPECIALTY_MEMORY !== "false",
 };
 let agentRuleCache = null;
 async function loadAgentRules() {
@@ -40,7 +43,6 @@ async function loadAgentRules() {
         }
     }
     catch {
-        // Fallback: use discipline rules file
         agentRuleCache = new Map();
     }
     return agentRuleCache;
@@ -52,9 +54,8 @@ async function loadAgentRules() {
 export function detectAgent(toolName, args) {
     if (CONFIG.FORCE_AGENT)
         return CONFIG.FORCE_AGENT;
-    // Build context from args for routing
     const contextParts = [toolName];
-    for (const [key, value] of Object.entries(args)) {
+    for (const [, value] of Object.entries(args)) {
         if (typeof value === "string") {
             contextParts.push(value);
         }
@@ -63,7 +64,6 @@ export function detectAgent(toolName, args) {
         }
     }
     const context = contextParts.join(" ").substring(0, 500);
-    // Use RoutingEngine to detect the best agent
     return RoutingEngine.resolveAgent(context);
 }
 /**
@@ -88,9 +88,32 @@ export async function getAgentPrompt(agentName) {
         "> They supplement (not replace) your existing instructions.",
     ].join("\n");
 }
+/**
+ * Load specialty memory for an agent and format it for injection.
+ */
+function getSpecialtyMemoryContext(agentName) {
+    if (!CONFIG.INJECT_SPECIALTY_MEMORY)
+        return null;
+    try {
+        const conventions = EvaluationEngine.readLearnedConventions(agentName);
+        if (!conventions)
+            return null;
+        return [
+            "",
+            "### Previously Learned Conventions",
+            `The following lessons were learned from past tasks for @${agentName}:`,
+            "",
+            conventions,
+            "",
+        ].join("\n");
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Build a silent context injection payload.
- * This is prepended to tool responses to guide the AI without @agent commands.
+ * Injects agent rules + specialty memory into tool responses.
  */
 export async function buildSilentContext(detectedAgent, toolName, responseText) {
     if (!CONFIG.ENABLED)
@@ -98,14 +121,17 @@ export async function buildSilentContext(detectedAgent, toolName, responseText)
     const agentPrompt = await getAgentPrompt(detectedAgent);
     if (!agentPrompt)
         return responseText;
-    // Only inject if the response is substantial enough to warrant governance
     if (responseText.length < 50)
         return responseText;
-    // Inject as a comment block that won't break tool results
+    // Inject specialty memory if available
+    const specialtyContext = getSpecialtyMemoryContext(detectedAgent);
+    const fullPrompt = specialtyContext
+        ? `${agentPrompt}\n${specialtyContext}`
+        : agentPrompt;
     const injection = [
         "",
         `<!-- ATABEY_GOVERNANCE agent="${detectedAgent}" tool="${toolName}" -->`,
-        `${agentPrompt}`,
+        `${fullPrompt}`,
         "<!-- /ATABEY_GOVERNANCE -->",
         "",
     ].join("\n");

package/framework-mcp/dist/src/modules/engines/evaluation-engine.js

@@ -0,0 +1,169 @@
+import fs from "fs";
+import path from "path";
+import { scanProjectCompliance } from "../../cli/utils/compliance.js";
+import { getFrameworkDir } from "../../cli/utils/memory.js";
+import { appendFile, ensureDir, runCommandQuiet, writeTextFile } from "../../shared/fs.js";
+import { logger } from "../../shared/logger.js";
+import { asTraceID } from "../../shared/types.js";
+export class EvaluationEngine {
+    /**
+     * Evaluates a completed task, calculates a score, and updates Specialty Memory.
+     * Saves lessons from both failures AND successes.
+     */
+    static evaluateTask(traceIdStr, agentName, durationMs, taskDescription) {
+        const traceId = asTraceID(traceIdStr);
+        logger.debug(`Starting evaluation for Trace ${traceId} by ${agentName}`);
+        let score = 100;
+        const metrics = {
+            compilation: true,
+            lint: true,
+            tests: true,
+            compliance: 0
+        };
+        const projectRoot = process.cwd();
+        const lessons = [];
+        // 1. Compliance Check (AST-based discipline check)
+        try {
+            const issues = scanProjectCompliance("src");
+            metrics.compliance = issues.length;
+            if (issues.length > 0) {
+                score -= Math.min(issues.length * 5, 40);
+                lessons.push("Compliance Violations Detected: Ensure strict adherence to zero-any, zero-console.log policies.");
+            }
+            else {
+                lessons.push("Compliance check passed: No any types or console.log violations found.");
+            }
+        }
+        catch (e) {
+            logger.debug("Compliance check failed during evaluation", e);
+        }
+        // 2. Compilation Check
+        try {
+            if (fs.existsSync(path.join(projectRoot, "tsconfig.json"))) {
+                runCommandQuiet("npx", ["tsc", "--noEmit"], projectRoot);
+                lessons.push("TypeScript compilation succeeded. Project is type-safe.");
+            }
+        }
+        catch {
+            metrics.compilation = false;
+            score -= 20;
+            lessons.push("Compilation Error: Always run 'npx tsc --noEmit' to verify type safety before completing a task.");
+        }
+        // 3. Lint Check
+        try {
+            if (fs.existsSync(path.join(projectRoot, "eslint.config.js"))) {
+                runCommandQuiet("npx", ["eslint", ".", "--max-warnings", "0"], projectRoot);
+                lessons.push("Lint check passed. Code follows project style guidelines.");
+            }
+        }
+        catch {
+            metrics.lint = false;
+            score -= 10;
+        }
+        // 4. Test Check
+        try {
+            if (fs.existsSync(path.join(projectRoot, "vitest.config.ts"))) {
+                runCommandQuiet("npx", ["vitest", "run", "--passWithNoTests"], projectRoot);
+                lessons.push("All tests passed. Changes are verified.");
+            }
+        }
+        catch {
+            metrics.tests = false;
+            score -= 20;
+            lessons.push("Test Failure: Ensure all unit tests pass before marking a task as COMPLETED.");
+        }
+        // 5. Efficiency Check
+        if (durationMs > 120000) {
+            score -= 10;
+            lessons.push("Task took longer than 2 minutes. Consider breaking large tasks into smaller steps.");
+        }
+        else if (score >= 80) {
+            lessons.push("Task completed efficiently within expected timeframe.");
+        }
+        // 6. Success Lesson — if score is high and no critical errors
+        if (score >= 80 && taskDescription) {
+            const successLesson = this.extractSuccessLesson(agentName, taskDescription);
+            if (successLesson) {
+                lessons.push(successLesson);
+            }
+        }
+        // Save all lessons to specialty memory
+        for (const lesson of lessons) {
+            this.updateSpecialtyMemory(agentName, lesson);
+        }
+        const result = {
+            traceId,
+            agent: agentName.replace("@", ""),
+            score: Math.max(0, score),
+            metrics,
+            durationMs,
+            timestamp: new Date().toISOString()
+        };
+        logger.debug(`Evaluation completed for ${agentName}: Score ${result.score}/100`);
+        return result;
+    }
+    /**
+     * Extract a meaningful success lesson from a completed task.
+     */
+    static extractSuccessLesson(agentName, taskDescription) {
+        const patterns = [
+            { keywords: ["api", "endpoint", "route", "rest"], lesson: "REST API pattern used successfully for this task." },
+            { keywords: ["auth", "login", "jwt", "token"], lesson: "Authentication/authorization pattern used successfully." },
+            { keywords: ["test", "spec", "vitest"], lesson: "Test-driven approach used successfully." },
+            { keywords: ["migration", "schema", "database", "sql"], lesson: "Database schema/migration pattern used successfully." },
+            { keywords: ["component", "react", "ui", "page"], lesson: "UI component pattern used successfully for this task." },
+            { keywords: ["middleware", "guard", "interceptor"], lesson: "Middleware/guard pattern used successfully." },
+            { keywords: ["service", "repository", "inject"], lesson: "Service/repository pattern used successfully." },
+            { keywords: ["error", "exception", "catch", "try"], lesson: "Error handling pattern used successfully." },
+            { keywords: ["config", "env", "environment"], lesson: "Configuration/environment pattern used successfully." },
+        ];
+        const lower = taskDescription.toLowerCase();
+        for (const { keywords, lesson } of patterns) {
+            if (keywords.some(k => lower.includes(k))) {
+                return lesson;
+            }
+        }
+        // Generic success lesson if no specific pattern matched
+        return "Task completed with score >= 80. Pattern/approach used was effective.";
+    }
+    /**
+     * Reads learned conventions from an agent's specialty memory.
+     * Used by silent-router to inject context into AI calls.
+     */
+    static readLearnedConventions(agentName) {
+        const cleanName = agentName.replace("@", "");
+        const fwDir = getFrameworkDir();
+        const filePath = path.join(fwDir, "memory", "specialties", `${cleanName}.md`);
+        try {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, "utf8").trim();
+                if (content)
+                    return content;
+            }
+        }
+        catch {
+            // File might not exist yet
+        }
+        return "";
+    }
+    /**
+     * Appends learned lessons to the agent's specialty memory.
+     */
+    static updateSpecialtyMemory(agentName, lesson) {
+        const cleanName = agentName.replace("@", "");
+        const fwDir = getFrameworkDir();
+        const specialtiesDir = path.join(fwDir, "memory", "specialties");
+        ensureDir(specialtiesDir);
+        const filePath = path.join(specialtiesDir, `${cleanName}.md`);
+        const timestamp = new Date().toISOString().split("T")[0];
+        const entry = `- **[${timestamp}]**: ${lesson}\n`;
+        if (!fs.existsSync(filePath)) {
+            writeTextFile(filePath, `# Learned Conventions for @${cleanName}\n\n`);
+        }
+        // Avoid duplicate lessons on the same day
+        const currentContent = fs.readFileSync(filePath, "utf8");
+        if (!currentContent.includes(lesson)) {
+            appendFile(filePath, entry);
+        }
+    }
+}

package/framework-mcp/dist/src/shared/pii.js

@@ -150,7 +150,7 @@ export function containsPIIInObject(obj, depth = 0) {
     if (Array.isArray(obj)) {
         return obj.some(item => containsPIIInObject(item, depth + 1));
     }
-    for (const [_key, value] of Object.entries(obj)) {
+    for (const [, value] of Object.entries(obj)) {
         if (typeof value === "string") {
             if (containsPII(value))
                 return true;

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

@@ -18,7 +18,7 @@ export class AtabeyStorage {
                 fs.mkdirSync(frameworkDir, { recursive: true });
             }
             const dbPath = path.join(frameworkDir, "atabey.db");
-            this.db = new Database(dbPath);
+            this.db = new Database(dbPath, { timeout: 5000 });
             this.db.pragma("journal_mode = WAL");
             this.initializeSchema();
         }

package/framework-mcp/package.json

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

package/mcp.json

@@ -4,16 +4,17 @@
       "command": "atabey",
       "args": ["mcp", "start"],
       "env": {
+        "MCP_TRANSPORT": "stdio",
         "ATABEY_PROJECT_ROOT": "/Users/ybekar/Desktop/Projeler/atabey"
       },
-      "description": "Stdio mode: her kullanici kendi IDE'sinden baglanir."
+      "description": "Stdio mode: each developer connects from their own IDE."
     },
     "atabey-sse": {
       "url": "http://localhost:5858/mcp/sse",
       "env": {
         "ATABEY_PROJECT_ROOT": "/Users/ybekar/Desktop/Projeler/atabey"
       },
-      "description": "Unified mode: Tek port 5858'de MCP + Dashboard birlikte. Dashboard: http://localhost:5858"
+      "description": "Unified mode: MCP + Dashboard on single port 5858. Dashboard: http://localhost:5858"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atabey",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "MCP-Powered AI Governance & Autonomous Orchestration Framework. Plugs into Claude Code, Gemini CLI, and Cursor as an MCP server.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -89,11 +89,10 @@
     "globals": "^17.6.0",
     "tsx": "^4.22.3",
     "typescript-eslint": "^8.0.0",
-    "vitest": "^3.0.0",
-    "atabey": "^0.0.14"
+    "vitest": "^3.0.0"
   },
   "atabey": {
-    "version": "0.0.14",
+    "version": "0.0.15",
     "initializedAt": "2026-06-20T15:11:43.308Z"
   }
 }