atabey 0.0.6 → 0.0.8

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

@@ -0,0 +1,49 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../../cli/utils/memory.js";
+import { ensureDir, writeJsonFile } from "../../shared/fs.js";
+/**
+ * [DATA] Evaluation & Health Engine
+ * Rates agent performance and tracks overall project stability.
+ */
+export class HealthEngine {
+    /**
+     * Records a post-task evaluation.
+     */
+    static async recordEvaluation(result) {
+        const evalDir = path.join(getFrameworkDir(), "memory", "evaluations");
+        ensureDir(evalDir);
+        const filePath = path.join(evalDir, `${result.traceId}_${result.agent}.json`);
+        writeJsonFile(filePath, result);
+        // Trigger health update
+        await this.updateProjectHealth();
+    }
+    /**
+     * Aggregates all data to calculate the overall Project Health.
+     */
+    static async updateProjectHealth() {
+        // This would normally read compliance reports, test results, and recent evaluations
+        // Prototyping with semi-static values for now
+        const health = {
+            score: 85,
+            codeQuality: 90,
+            security: 80,
+            architecture: 85,
+            lastUpdated: new Date().toISOString()
+        };
+        const healthFile = path.join(getFrameworkDir(), "memory", "HEALTH.json");
+        writeJsonFile(healthFile, health);
+        return health;
+    }
+    static getHealth() {
+        try {
+            const healthFile = path.join(getFrameworkDir(), "memory", "HEALTH.json");
+            if (!fs.existsSync(healthFile))
+                return null;
+            return JSON.parse(fs.readFileSync(healthFile, "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+import { generateULID } from "../../cli/utils/time.js";
+import { RoutingEngine } from "./routing-engine.js";
+/**
+ * 🗺️ Planning Engine (The Strategist)
+ * Responsible for decomposing complex requests into a DAG of atomic tasks.
+ */
+export class PlanningEngine {
+    /**
+     * Creates a new Plan structure.
+     * In a real enterprise scenario, this would be fueled by an LLM prompt.
+     * For now, it provides the structural backbone.
+     */
+    static createPlan(rawTasks) {
+        const planId = generateULID();
+        const tasks = rawTasks.map((t, index) => {
+            const id = t.id || `TASK_${String(index + 1).padStart(2, "0")}`;
+            return {
+                id,
+                agent: t.agent || RoutingEngine.resolveAgent(t.task),
+                task: t.task,
+                dependencies: t.dependencies || []
+            };
+        });
+        return {
+            planId,
+            tasks
+        };
+    }
+    /**
+     * Validates a plan's integrity (no circular dependencies, all agents valid).
+     */
+    static validatePlan(plan) {
+        const errors = [];
+        const taskIds = new Set(plan.tasks.map(t => t.id));
+        for (const task of plan.tasks) {
+            // Check dependencies exist
+            for (const dep of task.dependencies) {
+                if (!taskIds.has(dep)) {
+                    errors.push(`Task ${task.id} has non-existent dependency: ${dep}`);
+                }
+            }
+            // Check circular dependencies (simple check for now)
+            if (task.dependencies.includes(task.id)) {
+                errors.push(`Task ${task.id} cannot depend on itself.`);
+            }
+        }
+        // Circular dependency detection using DFS
+        const visited = new Set();
+        const recStack = new Set();
+        const hasCycle = (taskId) => {
+            if (recStack.has(taskId))
+                return true;
+            if (visited.has(taskId))
+                return false;
+            visited.add(taskId);
+            recStack.add(taskId);
+            const task = plan.tasks.find(t => t.id === taskId);
+            if (task) {
+                for (const dep of task.dependencies) {
+                    if (hasCycle(dep))
+                        return true;
+                }
+            }
+            recStack.delete(taskId);
+            return false;
+        };
+        for (const task of plan.tasks) {
+            if (hasCycle(task.id)) {
+                errors.push("Circular dependency detected in plan.");
+                break;
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}

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

@@ -0,0 +1,105 @@
+/**
+ * [SECURITY] Risk Engine (The Guardian)
+ * Calculates the danger level of a proposed task or operation.
+ */
+export class RiskEngine {
+    static HIGH_RISK_KEYWORDS = [
+        { word: "delete", weight: 40 },
+        { word: "drop", weight: 50 },
+        { word: "truncate", weight: 50 },
+        { word: "rm -rf", weight: 60 },
+        { word: "purge", weight: 40 },
+        { word: "format", weight: 50 },
+        { word: "force", weight: 20 },
+    ];
+    static SENSITIVE_PATHS = [
+        { pattern: /\.env/, weight: 50 },
+        { pattern: /config/, weight: 20 },
+        { pattern: /database\//, weight: 30 },
+        { pattern: /auth\//, weight: 30 },
+        { pattern: /security/, weight: 30 },
+        { pattern: /atabey/, weight: 40 }, // Framework protection
+    ];
+    /**
+     * Assesses the risk of a natural language task or command string.
+     */
+    static assessTaskRisk(task) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Keyword Analysis
+        for (const { word, weight } of this.HIGH_RISK_KEYWORDS) {
+            if (new RegExp(`\\b${word}\\b`, "i").test(task)) {
+                factors.push({
+                    factor: `Keyword: ${word}`,
+                    score: weight,
+                    description: `Detected high-risk keyword '${word}' in task description.`
+                });
+                totalScore += weight;
+            }
+        }
+        // 2. Path Sensitivity (if paths are mentioned in the task)
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(task)) {
+                factors.push({
+                    factor: `Sensitive Path: ${pattern.source}`,
+                    score: weight,
+                    description: `Task involves access to sensitive path or pattern: ${pattern.source}`
+                });
+                totalScore += weight;
+            }
+        }
+        // 3. Complexity Risk (Length of task as a proxy)
+        if (task.length > 300) {
+            const score = 10;
+            factors.push({
+                factor: "High Complexity",
+                score,
+                description: "Task description is unusually long, increasing the chance of misunderstanding."
+            });
+            totalScore += score;
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    /**
+     * Assesses risk based on a proposed file change.
+     */
+    static assessChangeRisk(filePath, operation) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Operation Weight
+        const opWeights = { write: 30, replace: 5, patch: 10 };
+        totalScore += opWeights[operation];
+        factors.push({
+            factor: `Operation: ${operation}`,
+            score: opWeights[operation],
+            description: `A '${operation}' operation is inherently riskier than a surgical 'replace'.`
+        });
+        // 2. File Path Risk
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(filePath)) {
+                factors.push({
+                    factor: `Sensitive File: ${filePath}`,
+                    score: weight,
+                    description: "Modifying a sensitive file is high risk."
+                });
+                totalScore += weight;
+            }
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    static finalizeAssessment(totalScore, factors) {
+        let severity = "LOW";
+        if (totalScore >= 80)
+            severity = "CRITICAL";
+        else if (totalScore >= 50)
+            severity = "HIGH";
+        else if (totalScore >= 20)
+            severity = "MEDIUM";
+        return {
+            totalScore: Math.min(totalScore, 100),
+            severity,
+            factors,
+            requiresApproval: totalScore >= 60
+        };
+    }
+}

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

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../../cli/utils/memory.js";
+import { ALL_AGENTS } from "../agents/definitions.js";
+export class RoutingEngine {
+    /**
+     * Finds the best agent for a given task description based on capability scores and specialties.
+     */
+    static resolveAgent(taskDescription) {
+        const textLower = taskDescription.toLowerCase();
+        const candidates = this.getCandidates();
+        let bestAgent = "@backend"; // Default fallback
+        let bestScore = 0;
+        for (const candidate of candidates) {
+            let candidateScore = 0;
+            for (const [specialty, weight] of Object.entries(candidate.specialties)) {
+                const specLower = specialty.toLowerCase();
+                if (textLower.includes(specLower)) {
+                    candidateScore += weight;
+                }
+            }
+            if (candidateScore > bestScore) {
+                bestScore = candidateScore;
+                bestAgent = candidate.agent;
+            }
+        }
+        // Static fallback keywords if no specialty match found
+        if (bestScore === 0) {
+            if (textLower.includes("frontend") || textLower.includes("ui") || textLower.includes("page") || textLower.includes("css") || textLower.includes("html") || textLower.includes("react")) {
+                bestAgent = "@frontend";
+            }
+            else if (textLower.includes("security") || textLower.includes("audit") || textLower.includes("auth") || textLower.includes("token")) {
+                bestAgent = "@security";
+            }
+            else if (textLower.includes("database") || textLower.includes("migration") || textLower.includes("sql") || textLower.includes("schema") || textLower.includes("postgres")) {
+                bestAgent = "@database";
+            }
+            else if (textLower.includes("docker") || textLower.includes("ci") || textLower.includes("deploy") || textLower.includes("devops")) {
+                bestAgent = "@devops";
+            }
+        }
+        return bestAgent;
+    }
+    static getCandidates() {
+        const frameworkDir = getFrameworkDir();
+        const registryDir = path.join(frameworkDir, "registry");
+        let candidates = [];
+        // 1. Try Control Plane Registry first (active registered agents)
+        if (fs.existsSync(registryDir)) {
+            const registryFiles = fs.readdirSync(registryDir).filter(f => f.endsWith("_active.json"));
+            for (const file of registryFiles) {
+                try {
+                    const data = JSON.parse(fs.readFileSync(path.join(registryDir, file), "utf8"));
+                    if (data.agent && data.specialties) {
+                        candidates.push({
+                            agent: data.agent,
+                            specialties: data.specialties
+                        });
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        // 2. Fallback to built-in agent definitions
+        if (candidates.length === 0) {
+            candidates = ALL_AGENTS.map(ag => ({
+                agent: ag.name.startsWith("@") ? ag.name : `@${ag.name}`,
+                specialties: ag.specialties || {}
+            }));
+        }
+        return candidates;
+    }
+}

package/framework-mcp/dist/src/modules/engines/types.js

@@ -0,0 +1 @@
+export {};

package/{src/modules/skills/definitions.ts → framework-mcp/dist/src/modules/skills/definitions.js}

@@ -2,7 +2,6 @@
  * Core Skill Definitions for Agent Atabey.
  * Groups tools into logical capabilities for agents.
  */
-
 export const CORE_SKILLS = {
     FILE_SYSTEM: {
         name: "File System Mastery",

package/{src/shared/constants.ts → framework-mcp/dist/src/shared/constants.js}

@@ -2,9 +2,7 @@
  * Agent Atabey — Single Source of Truth for framework constants.
  * Import from here instead of hardcoding paths, phases, or directory names.
  */
-
 // ─── Framework identity ───────────────────────────────────────────────────────
-
 export const FRAMEWORK = {
     NAME: "Agent Atabey",
     CORE_DIR: ".atabey",
@@ -13,29 +11,26 @@ export const FRAMEWORK = {
     DEFAULT_TRACE_ID: "T-000",
     DEFAULT_PHASE: "PHASE_0",
     DEFAULT_MANAGER_STATE: "ACTIVE",
-} as const;
-
+    DASHBOARD_PORT: 5858,
+};
 export const PROJECT_PHASES = [
     "PHASE_0",
     "PHASE_1",
     "PHASE_2",
     "PHASE_3",
     "PHASE_4",
-] as const;
-
+];
 // ─── Adapter platform directories (native / legacy) ───────────────────────────
-
 export const ADAPTER_DIRS = {
     GEMINI: ".gemini",
     CLAUDE: ".claude",
     GROK: ".grok",
     CURSOR: ".cursor",
     CODEX: ".agents",
-    ANTIGRAVITY: ".antigravity",
+    ANTIGRAVITY: ".agents",
     LOCAL: ".atabey",
     LEGACY_AGENT: ".agent",
-} as const;
-
+};
 /** Priority order for framework directory resolution (CLI + MCP). */
 export const FRAMEWORK_DIR_CANDIDATES = [
     FRAMEWORK.CORE_DIR,
@@ -46,8 +41,7 @@ export const FRAMEWORK_DIR_CANDIDATES = [
     ADAPTER_DIRS.CURSOR,
     ADAPTER_DIRS.ANTIGRAVITY,
     ADAPTER_DIRS.LOCAL,
-] as const;
-
+];
 /** Slug under `.agents/{slug}/` for each adapter in unified mode. */
 export const UNIFIED_ADAPTER_SLUG = {
     gemini: "gemini",
@@ -57,12 +51,8 @@ export const UNIFIED_ADAPTER_SLUG = {
     codex: "codex",
     local: "local",
     "antigravity-cli": "antigravity",
-} as const;
-
-export type UnifiedAdapterSlug = keyof typeof UNIFIED_ADAPTER_SLUG;
-
+};
 // ─── Native agent instruction paths (legacy tool compatibility) ───────────────
-
 export const NATIVE_AGENT_PATHS = {
     gemini: pathJoin(ADAPTER_DIRS.GEMINI, "agents"),
     claude: pathJoin(ADAPTER_DIRS.CLAUDE, "agents"),
@@ -71,8 +61,7 @@ export const NATIVE_AGENT_PATHS = {
     codex: pathJoin(ADAPTER_DIRS.CODEX, "instructions"),
     local: pathJoin(ADAPTER_DIRS.LOCAL, "agents"),
     "antigravity-cli": pathJoin(ADAPTER_DIRS.ANTIGRAVITY, "agents"),
-} as const;
-
+};
 /** Legacy layout bases used by `check` and discovery (non-unified installs). */
 export const LEGACY_AGENT_LAYOUT_BASES = [
     NATIVE_AGENT_PATHS.gemini,
@@ -82,10 +71,8 @@ export const LEGACY_AGENT_LAYOUT_BASES = [
     NATIVE_AGENT_PATHS.codex,
     NATIVE_AGENT_PATHS.local,
     NATIVE_AGENT_PATHS["antigravity-cli"],
-] as const;
-
+];
 // ─── Framework internal subdirectories (under `.atabey/`) ──────────────────
-
 export const FRAMEWORK_SUBDIRS = {
     AGENTS: "agents",
     SKILLS: "skills",
@@ -99,8 +86,9 @@ export const FRAMEWORK_SUBDIRS = {
     MESSAGES: "messages",
     LOGS: "logs",
     MEMORY_GRAPH: "memory-graph",
-} as const;
-
+    DASHBOARD: "dashboard",
+    UI_DIST: "ui",
+};
 export const CORE_SCAFFOLD_SUBDIRS = [
     FRAMEWORK_SUBDIRS.KNOWLEDGE,
     FRAMEWORK_SUBDIRS.PROMPTS,
@@ -109,71 +97,61 @@ export const CORE_SCAFFOLD_SUBDIRS = [
     FRAMEWORK_SUBDIRS.REGISTRY,
     FRAMEWORK_SUBDIRS.OBSERVABILITY,
     FRAMEWORK_SUBDIRS.RULES,
-] as const;
-
+];
 export const RUNTIME_SUBDIRS = [
     FRAMEWORK_SUBDIRS.MESSAGES,
     FRAMEWORK_SUBDIRS.LOGS,
     FRAMEWORK_SUBDIRS.MEMORY_GRAPH,
-] as const;
-
+];
 export const MEMORY_SUBDIRS = {
     TASKS: "tasks",
     HISTORY: "history",
-} as const;
-
+};
 export const MEMORY_FILES = {
     STATE: "state.json",
     STATUS: "status.json",
     PROJECT_MEMORY: "PROJECT_MEMORY.md",
     SHARED_FACTS: "shared-facts.json",
-} as const;
-
+};
 // ─── Monorepo default paths ───────────────────────────────────────────────────
-
 export const DEFAULT_MONOREPO_PATHS = {
     backend: "apps/backend",
     frontend: "apps/web",
     mobile: "apps/mobile",
     docs: "docs",
     tests: "tests",
-} as const;
-
+};
 /** Cursor rule globs per agent role (enterprise monorepo layout). */
-export const CURSOR_AGENT_GLOBS: Record<string, string> = {
-    manager:   "**/*",
-    security:  "**/*",
+export const CURSOR_AGENT_GLOBS = {
+    manager: "**/*",
+    security: "**/*",
     architect: "**/*",
-    backend:   `${DEFAULT_MONOREPO_PATHS.backend}/**/*`,
-    frontend:  `${DEFAULT_MONOREPO_PATHS.frontend}/**/*`,
-    mobile:    `${DEFAULT_MONOREPO_PATHS.mobile}/**/*`,
-    native:    "apps/native/**/*",
-    database:  `${DEFAULT_MONOREPO_PATHS.backend}/src/database/**/*`,
-    devops:    "{.github,docker,infra,scripts,*.yml,*.yaml,Dockerfile*}",
-    quality:   "**/*",
-    analyst:   "{docs,specs,contracts}/**/*",
-    explorer:  "**/*",
-    git:       "**/*",
+    backend: `${DEFAULT_MONOREPO_PATHS.backend}/**/*`,
+    frontend: `${DEFAULT_MONOREPO_PATHS.frontend}/**/*`,
+    mobile: `${DEFAULT_MONOREPO_PATHS.mobile}/**/*`,
+    native: "apps/native/**/*",
+    database: `${DEFAULT_MONOREPO_PATHS.backend}/src/database/**/*`,
+    devops: "{.github,docker,infra,scripts,*.yml,*.yaml,Dockerfile*}",
+    quality: "**/*",
+    analyst: "{docs,specs,contracts}/**/*",
+    explorer: "**/*",
+    git: "**/*",
 };
-
 // ─── MCP & environment ──────────────────────────────────────────────────────
-
 export const MCP = {
     SERVER_NAME: "atabey",
     ROOT_CONFIG_FILE: "mcp.json",
     PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
     TEST_DIR_ENV: "ATABEY_TEST_DIR",
-} as const;
-
+    SERVER_DIST_PATH: "framework-mcp/dist/index.js",
+};
 export const ROOT_CONFIG_FILES = {
     MCP: MCP.ROOT_CONFIG_FILE,
     DOT_MCP: ".mcp.json",
     ENV_EXAMPLE: ".env.example",
     VSCODE_MCP: ".vscode/mcp.json",
-} as const;
-
+};
 // ─── Shim template placeholders ───────────────────────────────────────────────
-
 export const TEMPLATE_PLACEHOLDERS = {
     FRAMEWORK_DIR: "{{FRAMEWORK_DIR}}",
     ADAPTER: "{{ADAPTER}}",
@@ -181,37 +159,28 @@ export const TEMPLATE_PLACEHOLDERS = {
     FRONTEND_DIR: "{{FRONTEND_DIR}}",
     DOCS_DIR: "{{DOCS_DIR}}",
     TESTS_DIR: "{{TESTS_DIR}}",
-} as const;
-
+};
 // ─── File extensions ─────────────────────────────────────────────────────────
-
 export const AGENT_FILE_EXT = {
     MARKDOWN: ".md",
     CURSOR_RULE: ".mdc",
-} as const;
-
+};
 // ─── Path helpers ─────────────────────────────────────────────────────────────
-
-export function pathJoin(...segments: string[]): string {
+export function pathJoin(...segments) {
     return segments.filter(Boolean).join("/");
 }
-
-export function corePath(...segments: string[]): string {
+export function corePath(...segments) {
     return pathJoin(FRAMEWORK.CORE_DIR, ...segments);
 }
-
-export function unifiedHubPath(...segments: string[]): string {
+export function unifiedHubPath(...segments) {
     return pathJoin(FRAMEWORK.UNIFIED_HUB_DIR, ...segments);
 }
-
-export function unifiedAdapterPath(slug: string, ...segments: string[]): string {
+export function unifiedAdapterPath(slug, ...segments) {
     return unifiedHubPath(slug, ...segments);
 }
-
-export function knowledgePath(filename: string): string {
+export function knowledgePath(filename) {
     return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
 }
-
 /** Backward-compatible aliases */
 export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
 export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;

package/{src/shared/errors.ts → framework-mcp/dist/src/shared/errors.js}

@@ -2,30 +2,27 @@
  * Enterprise Base Error class for the Agent Atabey Framework.
  */
 export class AtabeyBaseError extends Error {
-    public readonly code: string;
-    public readonly timestamp: Date;
-    public readonly details?: unknown;
-    public readonly solution?: string;
-
-    constructor(message: string, code = "ATABEY_INTERNAL_ERROR", details?: unknown, solution?: string) {
+    code;
+    timestamp;
+    details;
+    solution;
+    constructor(message, code = "ATABEY_INTERNAL_ERROR", details, solution) {
         super(message);
         this.name = this.constructor.name;
         this.code = code;
         this.timestamp = new Date();
         this.details = details;
         this.solution = solution;
-        
         // Ensure proper prototype chain and capture stack trace
         Object.setPrototypeOf(this, new.target.prototype);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         }
     }
-
     /**
      * Converts the error into a structured JSON log format.
      */
-    public toJSON() {
+    toJSON() {
         return {
             name: this.name,
             message: this.message,
@@ -37,39 +34,35 @@ export class AtabeyBaseError extends Error {
         };
     }
 }
-
 /**
  * Thrown when configuration loading or validation fails.
  */
 export class ConfigurationError extends AtabeyBaseError {
-    constructor(message: string, details?: unknown, solution?: string) {
+    constructor(message, details, solution) {
         super(message, "CONFIGURATION_ERROR", details, solution);
     }
 }
-
 /**
  * Thrown when data schema or payload validation fails.
  */
 export class ValidationError extends AtabeyBaseError {
-    constructor(message: string, details?: unknown, solution?: string) {
+    constructor(message, details, solution) {
         super(message, "VALIDATION_ERROR", details, solution);
     }
 }
-
 /**
  * Thrown when adapter initialization or execution fails.
  */
 export class AdapterError extends AtabeyBaseError {
-    constructor(message: string, adapterId: string, details?: unknown, solution?: string) {
+    constructor(message, adapterId, details, solution) {
         super(`Adapter '${adapterId}' failure: ${message}`, "ADAPTER_ERROR", details, solution);
     }
 }
-
 /**
  * Thrown when orchestration or agent communication fails.
  */
 export class OrchestrationError extends AtabeyBaseError {
-    constructor(message: string, details?: unknown, solution?: string) {
+    constructor(message, details, solution) {
         super(message, "ORCHESTRATION_ERROR", details, solution);
     }
 }