atabey 0.0.7 → 0.0.8

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

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { ensureDir, writeTextFile } from "../../utils/fs.js";
+import { getPackageRoot } from "../../utils/pkg.js";
+import { CORE_SKILLS } from "../../../modules/skills/definitions.js";
+const FRAMEWORK_NAME = "Agent Atabey";
+export function scaffoldSkills(skillsBaseDir, dryRun) {
+    if (dryRun)
+        return;
+    ensureDir(skillsBaseDir, dryRun);
+    for (const [key, skill] of Object.entries(CORE_SKILLS)) {
+        const mdContent = `# 🛠️ ${FRAMEWORK_NAME} Skill — ${skill.name}\n\n${skill.description}\n\n## 🔌 Associated Tools\n${skill.tools.map(t => `- \`${t}\``).join("\n")}\n\n## [SECURITY] Core Mandates\n${skill.mandates.join("\n")}\n`;
+        writeTextFile(path.join(skillsBaseDir, `${key.toLowerCase()}.md`), mdContent);
+    }
+}
+export function scaffoldStandards(frameworkDir, dryRun) {
+    if (dryRun)
+        return;
+    const knowledgePath = path.join(frameworkDir, "knowledge");
+    if (!fs.existsSync(knowledgePath))
+        fs.mkdirSync(knowledgePath, { recursive: true });
+    const eslintStandardsContent = `# [ATABEY] Agent Atabey — ESLint Standards
+
+This document outlines the strict ESLint coding standards for Agent Atabey projects.
+
+## 📏 Core Rules
+- **Indentation:** 4 spaces (strict).
+- **Quotes:** Double quotes (\`"\`) for strings.
+- **Semicolons:** Always terminate statements with a semicolon (\`;\`).
+- **No Explicit Any:** Avoid using \`any\`. Use strongly typed interfaces, generics, or \`unknown\` with type assertions.
+- **Unused Variables:** Warning on unused variables unless prefixed with an underscore (\`_\`).
+`;
+    writeTextFile(path.join(knowledgePath, "eslint-standards.md"), eslintStandardsContent);
+    const standards = [
+        // ── Supreme Governance (required by @manager, @security, @architect) ──────
+        { file: "governance-standards.md", template: "templates/standards/governance-standards.md", default: "# [ATABEY] Agent Atabey — Governance & Nizam Standards" },
+        // ── Core Engineering Standards ────────────────────────────────────────────
+        { file: "crud-governance.md", template: "templates/standards/crud-governance.md", default: "# [GOV] Corporate CRUD and Governance Standards" },
+        { file: "architecture-standards.md", template: "templates/standards/architecture-standards.md", default: "# 📐 Corporate Architecture Standards" },
+        { file: "frontend-standards.md", template: "templates/standards/frontend-standards.md", default: "# 🎨 Corporate Frontend Standards" },
+        { file: "vite-standards.md", template: "templates/standards/vite-standards.md", default: "# ⚡ Corporate Vite Standards" },
+        { file: "nextjs-standards.md", template: "templates/standards/nextjs-standards.md", default: "# ⚛️ Corporate Next.js Standards" },
+        { file: "tailwind-standards.md", template: "templates/standards/tailwind-standards.md", default: "# 🌊 Corporate Tailwind Standards" },
+        { file: "mobile-standards.md", template: "templates/standards/mobile-standards.md", default: "# 📱 Corporate Mobile Standards" },
+        { file: "security-standards.md", template: "templates/standards/security-standards.md", default: "# [SECURITY] Corporate Security Standards" },
+        { file: "quality-standards.md", template: "templates/standards/quality-standards.md", default: "# ⚖️ Corporate Code Quality Standards" },
+        { file: "logging-and-secrets.md", template: "templates/standards/logging-and-secrets.md", default: "# 🪵 Corporate Logging Standards" },
+        { file: "testing-standards.md", template: "templates/standards/testing-standards.md", default: "# [SKILL] Corporate Testing Standards" },
+        { file: "i18n-standards.md", template: "templates/standards/i18n-standards.md", default: "# 🌐 Corporate i18n Standards" },
+        { file: "llm-governance.md", template: "templates/standards/llm-governance.md", default: "# [AI] LLM Governance Standards" },
+        { file: "observability-standards.md", template: "templates/standards/observability-standards.md", default: "# 📈 Corporate Observability Standards" },
+        { file: "deployment-standards.md", template: "templates/standards/deployment-standards.md", default: "# [START] Corporate Deployment Standards" },
+        { file: "performance-standards.md", template: "templates/standards/performance-standards.md", default: "# ⚡ Corporate Performance Standards" },
+        { file: "security-audit-standards.md", template: "templates/standards/security-audit-standards.md", default: "# 🔍 Corporate Security Audit Standards" }
+    ];
+    for (const std of standards) {
+        let content = std.default;
+        try {
+            const fullTemplatePath = path.join(getPackageRoot(), std.template);
+            if (fs.existsSync(fullTemplatePath)) {
+                content = fs.readFileSync(fullTemplatePath, "utf8");
+            }
+        }
+        catch { /* fallback to default */ }
+        writeTextFile(path.join(knowledgePath, std.file), content);
+    }
+}

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

@@ -0,0 +1,167 @@
+import path from "path";
+import readline from "readline";
+import { resolveAdapter, runAdapterPostInit, scaffoldAgents, resolveAgentsDir, mirrorUnifiedAgentsToNative, ADAPTER_IDS, } from "../adapters/index.js";
+import { ensureDir } from "../utils/fs.js";
+import { initializeMemory, getConfiguredPaths } from "../utils/memory.js";
+import { getPackageVersion, getPackageRoot, mergePackageJson } from "../utils/pkg.js";
+import { UI } from "../utils/ui.js";
+import { ALL_AGENTS } from "../../modules/agents/definitions.js";
+import { scaffoldConstitution, scaffoldFrameworkConfigs, scaffoldShims } from "./init/scaffold-core.js";
+import { scaffoldSkills, scaffoldStandards } from "./init/scaffold-standards.js";
+import { scaffoldOps } from "./init/scaffold-ops.js";
+import { scaffoldProjectDocs } from "./init/scaffold-docs.js";
+import { TRANSLATIONS } from "../utils/i18n.js";
+const FRAMEWORK_NAME = "Agent Atabey";
+const FRAMEWORK_SUBDIRS = [
+    "agents",
+    "skills",
+    "knowledge",
+    "prompts",
+    "memory",
+    "router",
+    "registry",
+    "observability",
+    "rules",
+];
+async function runInteractiveInit() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+    try {
+        console.warn("\n🌐 Select Framework Language / Dil Seçimi:");
+        console.warn("1. Türkçe");
+        console.warn("2. English");
+        const langInput = await question("\nSelect (1-2) or Enter for 'tr': ");
+        const language = langInput.trim() === "2" ? "en" : "tr";
+        const t = TRANSLATIONS[language];
+        console.warn(`\n[START] ${t.welcome}`);
+        console.warn(`\n${t.select_backend}:`);
+        const languages = ["Node.js (TypeScript)", "Go", "Java (Spring Boot)", "Python (FastAPI)", ".NET"];
+        languages.forEach((l, i) => console.warn(`${i + 1}. ${l}`));
+        const bLangInput = await question("\nSelect (1-5) or Enter for \"Node.js\": ");
+        const backendLanguage = languages[parseInt(bLangInput.trim()) - 1] || "Node.js (TypeScript)";
+        console.warn(`\n${t.select_frontend}:`);
+        const frontendFrameworks = ["Vite (React)", "Next.js (App Router)", "Vanilla HTML/JS"];
+        frontendFrameworks.forEach((f, i) => console.warn(`${i + 1}. ${f}`));
+        const fFrameInput = await question("\nSelect (1-3) or Enter for \"Vite (React)\": ");
+        const frontendFramework = frontendFrameworks[parseInt(fFrameInput.trim()) - 1] || "Vite (React)";
+        console.warn("\nAvailable Framework Directories:");
+        FRAMEWORK_SUBDIRS.forEach((d, i) => console.warn(`${i + 1}. ${d}`));
+        const dirInput = await question(`\n${t.select_dirs} `);
+        const selectedDirs = dirInput ? dirInput.split(",").map(n => FRAMEWORK_SUBDIRS[parseInt(n.trim()) - 1]).filter(Boolean) : [...FRAMEWORK_SUBDIRS];
+        console.warn("\nAvailable Core Agents:");
+        ALL_AGENTS.forEach((a, i) => console.warn(`${i + 1}. ${a.name}`));
+        const agentInput = await question(`\n${t.select_agents} `);
+        const selectedAgents = agentInput ? agentInput.split(",").map(n => ALL_AGENTS[parseInt(n.trim()) - 1].name).filter(Boolean) : ALL_AGENTS.map(a => a.name);
+        console.warn("\nAvailable Color Palettes:");
+        const palettes = ["Modern Blue", "Enterprise Slate", "Deep Purple"];
+        palettes.forEach((p, i) => console.warn(`${i + 1}. ${p}`));
+        const palInput = await question(`\n${t.select_palette} `);
+        const selectedPalette = palettes[parseInt(palInput.trim()) - 1] || "Modern Blue";
+        return { selectedDirs, selectedAgents, selectedPalette, backendLanguage, frontendFramework, language };
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function initCommand(adapterName, options) {
+    const adapterId = (adapterName || "gemini");
+    const adapter = resolveAdapter(adapterId);
+    if (!adapter) {
+        UI.error(`Unknown adapter: ${adapterId}`);
+        process.exit(1);
+    }
+    const projectRoot = process.cwd();
+    const isUnified = options.unified || false;
+    // STRICT ISOLATION STRATEGY
+    const coreDir = ".atabey"; // Pure Memory & Knowledge
+    const aiToolDir = isUnified ? ".agents" : adapter.frameworkDir; // Pure Agents & Skills
+    const dryRun = options.dryRun || false;
+    const forceYes = options.yes || false;
+    UI.intent("Atabey Initialization", `Bootstrapping ${FRAMEWORK_NAME} (v${getPackageVersion()}) with ${adapterId} adapter...`);
+    let selectedDirs;
+    let selectedAgents;
+    let selectedPalette;
+    let backendLanguage;
+    let frontendFramework;
+    let language;
+    if (forceYes) {
+        selectedDirs = ["knowledge", "prompts", "memory", "router", "registry", "observability", "rules"];
+        selectedAgents = ALL_AGENTS.map(a => a.name);
+        selectedPalette = "Modern Blue";
+        backendLanguage = "Node.js (TypeScript)";
+        frontendFramework = "Vite (React)";
+        language = "tr";
+        UI.success("Non-interactive mode: Using default configurations (Language: tr, Backend: Node.js, Frontend: Vite).");
+    }
+    else {
+        const result = await runInteractiveInit();
+        selectedDirs = result.selectedDirs.filter(d => d !== "agents" && d !== "skills");
+        selectedAgents = result.selectedAgents;
+        selectedPalette = result.selectedPalette;
+        backendLanguage = result.backendLanguage;
+        frontendFramework = result.frontendFramework;
+        language = result.language;
+    }
+    const t = TRANSLATIONS[language];
+    ensureDir(path.join(projectRoot, coreDir), dryRun);
+    selectedDirs.forEach(dir => {
+        ensureDir(path.join(projectRoot, coreDir, dir), dryRun);
+    });
+    ensureDir(path.join(projectRoot, aiToolDir), dryRun);
+    if (adapter.nestedDirs) {
+        adapter.nestedDirs.forEach(dir => ensureDir(path.join(projectRoot, aiToolDir, dir), dryRun));
+    }
+    scaffoldConstitution(projectRoot, coreDir, adapterId, dryRun, language);
+    scaffoldFrameworkConfigs(projectRoot, coreDir, adapter, dryRun, selectedPalette, {
+        unified: isUnified,
+        adapters: isUnified ? [...ADAPTER_IDS] : [adapterId],
+        backendLanguage,
+        frontendFramework,
+        language
+    });
+    scaffoldStandards(path.join(projectRoot, coreDir), dryRun);
+    const pathsMap = getConfiguredPaths();
+    if (isUnified) {
+        // Scaffold ALL agents for ALL adapters under unified hub
+        for (const id of ADAPTER_IDS) {
+            const adapterId = id;
+            const dest = resolveAgentsDir(adapterId, true, aiToolDir);
+            scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
+            if (!dryRun)
+                mirrorUnifiedAgentsToNative(projectRoot, adapterId);
+        }
+        UI.success(`[OK] Scaffolding complete for all adapters under ${aiToolDir}/ with native mirrors.`);
+    }
+    else {
+        // Standard single-adapter scaffold
+        const dest = resolveAgentsDir(adapterId, false);
+        scaffoldAgents(projectRoot, adapterId, dryRun, selectedAgents, dest.agentsDir, dest.agentsExt, pathsMap, backendLanguage, language);
+        UI.success(`[OK] Generated agent definitions under ${dest.agentsDir}/`);
+    }
+    const skillsBaseDir = path.join(projectRoot, aiToolDir, "skills");
+    scaffoldSkills(skillsBaseDir, dryRun);
+    scaffoldOps(path.join(projectRoot, coreDir), dryRun);
+    scaffoldProjectDocs(projectRoot, { backendLanguage, frontendFramework }, dryRun);
+    scaffoldShims(projectRoot, coreDir, adapterId, adapter, dryRun, isUnified);
+    // Initialize runtime directories
+    if (!dryRun) {
+        ensureDir(path.join(projectRoot, coreDir, "messages"));
+        ensureDir(path.join(projectRoot, coreDir, "logs"));
+        ensureDir(path.join(projectRoot, coreDir, "memory-graph"));
+    }
+    initializeMemory(path.join(projectRoot, coreDir), dryRun);
+    // Scaffolding package.json
+    if (!dryRun) {
+        const pkgJsonPath = path.join(projectRoot, "package.json");
+        const sourcePkgPath = path.join(getPackageRoot(), "package.json");
+        mergePackageJson(pkgJsonPath, sourcePkgPath);
+    }
+    runAdapterPostInit(adapter, projectRoot);
+    UI.success(`\n[START] ${FRAMEWORK_NAME} (v${getPackageVersion()}) ${t.init_success}`);
+    console.warn(`\n- Brain & Memory Hub (Protected): ${coreDir}/`);
+    console.warn(`- AI Agent Commands (Active): ${aiToolDir}/`);
+    console.warn(`\n${t.next_steps}`);
+    console.warn("  1. Run 'npm install' (or pnpm/yarn) to install dependencies.");
+    console.warn("  2. Run 'atabey status' to verify the environment.");
+    console.warn(`  3. Open ${adapterId === "claude" ? "Claude Desktop" : "your AI Assistant"} and start commanding the Army.`);
+}

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

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../utils/memory.js";
+import { writeTextFile } from "../utils/fs.js";
+export async function updateKnowledgeBaseCommand(topic, content) {
+    if (!topic || !content) {
+        console.error("[ERROR] Usage: atabey update_knowledge_base <topic> <content>");
+        return;
+    }
+    const frameworkDir = getFrameworkDir();
+    const kbDir = path.join(frameworkDir, "knowledge");
+    if (!fs.existsSync(kbDir))
+        fs.mkdirSync(kbDir, { recursive: true });
+    const fileName = topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md";
+    writeTextFile(path.join(kbDir, fileName), content);
+    console.warn(`[OK] Knowledge base updated: ${topic}`);
+}
+export async function searchKnowledgeBaseCommand(query) {
+    if (!query) {
+        console.error("[ERROR] Usage: atabey search_knowledge_base <query>");
+        return;
+    }
+    const frameworkDir = getFrameworkDir();
+    const kbDir = path.join(frameworkDir, "knowledge");
+    if (!fs.existsSync(kbDir)) {
+        console.warn("ℹ️ Knowledge base is empty.");
+        return;
+    }
+    const files = fs.readdirSync(kbDir).filter(f => f.endsWith(".md"));
+    let found = false;
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(kbDir, file), "utf-8");
+        if (content.toLowerCase().includes(query.toLowerCase()) || file.toLowerCase().includes(query.toLowerCase())) {
+            console.warn(`
+### ${file.replace(".md", "")}
+${content.slice(0, 300)}...`);
+            found = true;
+        }
+    }
+    if (!found)
+        console.warn("ℹ️ No matching entries found.");
+}

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

@@ -0,0 +1,22 @@
+import { execSync } from "child_process";
+import { getPackageVersion } from "../utils/pkg.js";
+/**
+ * Run ESLint for the project (same as npm run lint).
+ */
+export async function lintCommand() {
+    console.warn(`🔍 Running ESLint (v${getPackageVersion()})...`);
+    const projectRoot = process.cwd();
+    try {
+        execSync("npm run lint", {
+            cwd: projectRoot,
+            stdio: "inherit",
+            env: process.env,
+        });
+        console.warn("\n[OK] ESLint passed with no errors.");
+    }
+    catch {
+        console.warn("\n[ERROR] ESLint reported errors. Fix violations before committing.");
+        console.warn("   Tip: npm run lint -- --fix");
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { normalizeAgentName } from "../utils/string.js";
+import { Storage } from "../../shared/storage.js";
+export async function logAgentActionCommand(data) {
+    const agent = normalizeAgentName(data.agent);
+    const db = Storage.getDB();
+    db.prepare(`
+        INSERT INTO logs (agent, action, trace_id, status, summary, findings)
+        VALUES (?, ?, ?, ?, ?, ?)
+    `).run(agent, data.action, data.traceId || null, data.status || "SUCCESS", data.summary || "", data.details ? JSON.stringify(data.details) : null);
+}

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

@@ -0,0 +1,4 @@
+import { updateProjectMemory } from "../utils/memory.js";
+export async function updateProjectMemoryCommand(section, content) {
+    updateProjectMemory(section, content);
+}

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

@@ -0,0 +1,159 @@
+import { UI } from "../utils/ui.js";
+import { z } from "zod";
+import { logger } from "../../shared/logger.js";
+import { sleep } from "../utils/time.js";
+import { Storage } from "../../shared/storage.js";
+import { asTraceID } from "../../shared/types.js";
+export const HermesMessageSchema = z.object({
+    timestamp: z.string(),
+    from: z.string(),
+    to: z.string(),
+    category: z.enum(["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"]),
+    content: z.string(), // This is the payload to be validated
+    traceId: z.string(),
+    parentId: z.string().optional(),
+    status: z.enum(["PENDING", "PROCESSED", "WAITING", "APPROVED"]),
+    priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional(),
+    action: z.string().optional(),
+    requiresApproval: z.boolean().optional(),
+    dependencies: z.array(z.string()).optional(),
+});
+let isLooping = false;
+export async function orchestrateCommand(options) {
+    UI.intent("Hermes Message Broker", "Starting the live agent orchestration loop...");
+    const maxIterations = options?.maxIterations;
+    let iterationCount = 0;
+    isLooping = true;
+    while (isLooping) {
+        try {
+            // 1. Check for agent timeouts using SQLite
+            const agents = Storage.getAllAgents();
+            for (const agent of agents) {
+                if (agent.state === "EXECUTING" && agent.last_updated) {
+                    const lastUpdatedTime = Date.parse(agent.last_updated);
+                    if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                        const displayAgent = `@${agent.name}`;
+                        UI.error(`[WARN]  Agent ${displayAgent} has TIMED OUT. Triggering Self-Healing...`);
+                        Storage.updateAgentStatus(agent.name, "READY", "Idle (Recovered from Timeout)");
+                        UI.success(`[OK] Hermes Self-Healing: ${displayAgent} reset to READY state.`);
+                    }
+                }
+            }
+            // 2. Fetch actionable messages from SQLite
+            const pendingMessages = Storage.getPendingMessages() || [];
+            if (pendingMessages.length > 0) {
+                UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks found in database.`);
+                for (const msg of pendingMessages) {
+                    // Dependency Check
+                    if (msg.parentId) {
+                        const tasks = Storage.getTasks(asTraceID(msg.traceId));
+                        const task = tasks.find(t => t.id === msg.parentId);
+                        if (task && task.dependencies.length > 0) {
+                            const incompleteDeps = tasks.filter(t => task.dependencies.includes(t.id) && t.status !== "COMPLETED");
+                            if (incompleteDeps.length > 0) {
+                                logger.debug(`Skipping task ${msg.parentId} for ${msg.to} - waiting for dependencies: ${incompleteDeps.map(d => d.id).join(", ")}`);
+                                continue;
+                            }
+                        }
+                    }
+                    // Risk and Approval Logic
+                    let riskFlag = false;
+                    try {
+                        const { RiskEngine } = await import("../../modules/engines/risk-engine.js");
+                        const assessment = RiskEngine.assessTaskRisk(msg.content);
+                        if (assessment.requiresApproval) {
+                            riskFlag = true;
+                            UI.warning(`[SECURITY]  Risk Engine auto-flagged Trace ${msg.traceId} as HIGH RISK`);
+                        }
+                    }
+                    catch { /* engine not ready */ }
+                    if ((msg.category === "ACTION" || msg.category === "ALERT" || riskFlag) && (msg.requiresApproval || riskFlag) && msg.status !== "APPROVED") {
+                        UI.warning(`\n[WARN]  [APPROVAL REQUEST] Trace ${msg.traceId} requires approval:`);
+                        UI.warning(`   Description: ${msg.content}`);
+                        const approved = await askUserApproval(msg.traceId, msg.content);
+                        if (approved && msg.id !== undefined) {
+                            Storage.updateMessageStatus(msg.id, "APPROVED");
+                            UI.success(`Approved trace: ${msg.traceId}`);
+                        }
+                        else if (msg.id !== undefined) {
+                            Storage.updateMessageStatus(msg.id, "PROCESSED"); // Mark as ignored/rejected
+                            continue;
+                        }
+                    }
+                    // Process message
+                    UI.agentBox(msg.to, msg.content, `Trace: ${msg.traceId} | From: ${msg.from} | Category: ${msg.category}`);
+                    let targetState = "EXECUTING";
+                    if (msg.category === "DELEGATION" || msg.category === "SUBTASK")
+                        targetState = "BRIEFED";
+                    let taskDescription = msg.content;
+                    try {
+                        const payload = JSON.parse(msg.content);
+                        taskDescription = payload.task || msg.content;
+                    }
+                    catch { /* ... */ }
+                    Storage.updateAgentStatus(msg.to, targetState, taskDescription);
+                    if (targetState === "BRIEFED") {
+                        Storage.updateAgentStatus(msg.to, "EXECUTING", taskDescription);
+                    }
+                    if (msg.id !== undefined) {
+                        Storage.updateMessageStatus(msg.id, "PROCESSED");
+                    }
+                }
+                // Sync to Markdown for human readability
+                const { syncMarkdownMemory } = await import("../utils/memory.js");
+                syncMarkdownMemory();
+            }
+        }
+        catch (globalLoopErr) {
+            UI.error(`[WARN]  Critical error in Hermes orchestration loop: ${globalLoopErr.message}`);
+        }
+        iterationCount++;
+        if (maxIterations !== undefined && iterationCount >= maxIterations) {
+            isLooping = false;
+            break;
+        }
+        await sleep(2000);
+    }
+}
+/**
+ * Standard tool for agents to delegate tasks to other agents.
+ */
+export async function sendMessage(args) {
+    try {
+        const message = {
+            timestamp: new Date().toISOString(),
+            from: args.from,
+            to: args.to,
+            category: args.category,
+            content: args.content,
+            traceId: asTraceID(args.traceId),
+            parentId: args.parentId,
+            status: "PENDING",
+            priority: args.priority || "NORMAL",
+            requiresApproval: args.requiresApproval || false
+        };
+        Storage.saveMessage(message);
+        return message;
+    }
+    catch (err) {
+        UI.error(`Message could not be delivered: ${args.from} -> ${args.to}`);
+        logger.debug("Hermes sendMessage failed", err);
+    }
+}
+async function askUserApproval(_traceId, _content) {
+    if (process.env.ATABEY_TEST_DIR || !process.stdin.isTTY) {
+        return false;
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question("[INFO] Approve this operation? (y/N): ", (answer) => {
+            rl.close();
+            const cleanAnswer = answer.trim().toLowerCase();
+            resolve(cleanAnswer === "y" || cleanAnswer === "yes");
+        });
+    });
+}

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

@@ -0,0 +1,117 @@
+import fs from "fs";
+import path from "path";
+import { generateULID } from "../utils/time.js";
+import { UI } from "../utils/ui.js";
+import { RoutingEngine } from "../../modules/engines/routing-engine.js";
+import { PlanningEngine } from "../../modules/engines/planning-engine.js";
+import { sendMessage } from "./orchestrate.js";
+import { Storage } from "../../shared/storage.js";
+import { asTraceID } from "../../shared/types.js";
+/**
+ * Submits a structured plan (DAG) to the framework.
+ */
+export async function submitPlanCommand(tasks) {
+    const traceId = asTraceID(generateULID());
+    const plan = PlanningEngine.createPlan(tasks);
+    const validation = PlanningEngine.validatePlan(plan);
+    if (!validation.valid) {
+        UI.error("Invalid Plan Submission:");
+        validation.errors.forEach((e) => UI.error(` - ${e}`));
+        process.exit(64);
+    }
+    UI.intent("Dynamic Task Planner", `Processing plan with ${plan.tasks.length} tasks (Plan Trace: ${traceId})`);
+    // Save plan metadata to SQLite
+    Storage.setMetadata(`plan_${traceId}`, JSON.stringify(plan));
+    for (const task of plan.tasks) {
+        const taskData = {
+            id: task.id,
+            traceId,
+            description: task.task,
+            agent: task.agent,
+            priority: "NORMAL",
+            status: "PENDING",
+            dependencies: task.dependencies || []
+        };
+        Storage.saveTask(taskData);
+        // Queue as a delegated message in SQLite
+        await sendMessage({
+            from: "@manager",
+            to: task.agent,
+            category: "DELEGATION",
+            content: JSON.stringify({ task: task.task, traceId }),
+            traceId,
+            parentId: task.id,
+            priority: "NORMAL",
+            dependencies: task.dependencies || []
+        });
+    }
+    UI.success(`[OK] Dynamic plan submitted and queued: ${plan.tasks.length} tasks.`);
+}
+/**
+ * Reads ALL markdown files from the docs/ directory and creates
+ * planning tasks from them. Agents will use this to understand
+ * project requirements and generate code accordingly.
+ */
+export async function planCommand() {
+    const projectRoot = process.cwd();
+    const docsDir = path.join(projectRoot, "docs");
+    if (!fs.existsSync(docsDir)) {
+        UI.error("Docs directory not found at docs/");
+        console.warn("[TIP]  Create a docs/ folder with your project requirements in .md files.");
+        return;
+    }
+    const entries = fs.readdirSync(docsDir, { withFileTypes: true });
+    const mdFiles = entries.filter(e => e.isFile() && e.name.endsWith(".md"));
+    if (mdFiles.length === 0) {
+        UI.warning("No markdown files found in docs/ directory.");
+        console.warn("[TIP]  Add .md files to docs/ with your project requirements.");
+        return;
+    }
+    UI.intent("Planning Engine", `Reading ${mdFiles.length} document(s) from docs/...`);
+    let totalTasks = 0;
+    for (const file of mdFiles) {
+        const filePath = path.join(docsDir, file.name);
+        const content = fs.readFileSync(filePath, "utf8");
+        const traceId = asTraceID(generateULID());
+        UI.success(`📄 docs/${file.name} (Trace: ${traceId})`);
+        // Extract checklist items and create sequential task chain
+        const taskRegex = /- \[ \]\s+(.+)/g;
+        let taskMatch;
+        let taskCount = 0;
+        let lastTaskId = null;
+        while ((taskMatch = taskRegex.exec(content)) !== null) {
+            const taskText = taskMatch[1].trim();
+            if (taskText.length >= 3) {
+                taskCount++;
+                totalTasks++;
+                // Capability routing via RoutingEngine
+                const targetAgent = RoutingEngine.resolveAgent(taskText);
+                const subTaskId = generateULID();
+                const taskData = {
+                    id: subTaskId,
+                    traceId,
+                    description: taskText,
+                    agent: targetAgent,
+                    priority: "NORMAL",
+                    status: "PENDING",
+                    dependencies: lastTaskId ? [lastTaskId] : []
+                };
+                Storage.saveTask(taskData);
+                // Queue as a delegated message
+                await sendMessage({
+                    from: "@manager",
+                    to: targetAgent,
+                    category: "DELEGATION",
+                    content: JSON.stringify({ task: taskText, traceId }),
+                    traceId,
+                    parentId: subTaskId,
+                    priority: "NORMAL",
+                    dependencies: lastTaskId ? [lastTaskId] : []
+                });
+                lastTaskId = subTaskId;
+            }
+        }
+        console.warn(`   📋 Actionable tasks detected: ${taskCount}`);
+    }
+    UI.success(`\n[OK] Planning complete: ${totalTasks} tasks identified.`);
+}

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

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+import cp from "child_process";
+const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
+export async function runScriptCommand(script, projectPath) {
+    const fullPath = path.join(targetDir, projectPath);
+    if (!fs.existsSync(fullPath)) {
+        console.warn(`[ERROR] Project path not found: ${projectPath}`);
+        return;
+    }
+    console.warn(`[START] Running 'npm run ${script}' in ${projectPath}...`);
+    try {
+        cp.spawnSync("npm", ["run", script], { cwd: fullPath, stdio: "inherit", shell: true });
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : "Unknown error";
+        console.warn(`[ERROR] Failed to run script: ${message}`);
+    }
+}

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

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import { collectFiles } from "../utils/fs.js";
+const targetDir = process.cwd();
+export async function securityAuditCommand(targetPath) {
+    console.warn(`🔍 Running Advanced Security Audit on: ${targetPath}...`);
+    const scanRules = [
+        { pattern: /sql`/, message: "Potential Raw SQL usage detected", severity: "HIGH" },
+        {
+            pattern: /(password|secret|api_?key)\s*[:=]\s*['"][^'"]+['"]/i,
+            message: "Potential hardcoded secret detected",
+            severity: "CRITICAL",
+        },
+        { pattern: /:\s*any(?!\w)/, message: "Usage of 'any' type detected", severity: "MEDIUM" },
+        { pattern: /\.innerHTML\s*=/, message: "Unsafe innerHTML assignment detected", severity: "MEDIUM" },
+    ];
+    const issues = [];
+    const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx", ".js", ".jsx"]);
+    files.forEach((f) => {
+        const content = fs.readFileSync(f, "utf8");
+        const lines = content.split("\n");
+        lines.forEach((line, i) => {
+            scanRules.forEach((rule) => {
+                if (rule.pattern.test(line)) {
+                    issues.push(`[${rule.severity}] ${rule.message} in ${path.relative(targetDir, f)}:${i + 1}`);
+                }
+            });
+        });
+    });
+    if (issues.length === 0) {
+        console.warn("[OK] No security issues detected.");
+    }
+    else {
+        issues.forEach((issue) => console.warn(`[WARN]  ${issue}`));
+    }
+}