atabey 0.0.9 → 0.0.11

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

@@ -1,167 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,159 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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}`));
-    }
-}