atabey 0.0.6 → 0.0.7

package/src/cli/commands/orchestrate.ts

@@ -1,450 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getFrameworkDir, updateDocumentStore, readStatus } from "../utils/memory.js";
-import { UI } from "../utils/ui.js";
-import { writeTextFile, appendFile } from "../utils/fs.js";
-import { z } from "zod";
-import { logger } from "../../shared/logger.js";
-import { TaskRequestSchema } from "../../contracts/tasks.js";
-import { sleep } from "../utils/time.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(),
-});
-
-export type HermesMessage = z.infer<typeof HermesMessageSchema>;
-
-// Global status cache for in-memory optimization
-let agentStatusCache: Record<string, { state: string; task: string; lastUpdated?: string }> = {};
-let isLooping = false;
-
-async function acquireMessageLock(lockPath: string): Promise<boolean> {
-    let retries = 5;
-    while (retries > 0) {
-        try {
-            if (fs.existsSync(lockPath)) {
-                try {
-                    const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 10000) {
-                        const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
-                        fs.renameSync(lockPath, tempLockPath);
-                        fs.unlinkSync(tempLockPath);
-                    }
-                } catch {
-                    // ignore
-                }
-            }
-            fs.writeFileSync(lockPath, `Locked by orchestrator at ${new Date().toISOString()}`, { flag: "wx" });
-            return true;
-        } catch (err: unknown) {
-            const error = err as { code?: string };
-            if (error.code === "EEXIST") {
-                retries--;
-                if (retries > 0) {
-                    await sleep(100);
-                }
-            } else {
-                return false;
-            }
-        }
-    }
-    return false;
-}
-
-function releaseMessageLock(lockPath: string) {
-    if (fs.existsSync(lockPath)) {
-        try {
-            fs.unlinkSync(lockPath);
-        } catch {
-            // ignore
-        }
-    }
-}
-
-export async function orchestrateCommand(options?: { maxIterations?: number }) {
-    UI.intent("Hermes Message Broker", "Starting the live agent orchestration loop...");
-
-    const frameworkDir = getFrameworkDir();
-    const messagesDir = path.join(frameworkDir, "messages");
-    const maxIterations = options?.maxIterations;
-    let iterationCount = 0;
-
-    // Reset in-memory cache so each invocation starts fresh (important for test isolation)
-    agentStatusCache = {};
-
-    // Graceful Shutdown Handling
-    const shutdown = async () => {
-        if (!isLooping) return;
-        isLooping = false;
-        UI.warning("\n🛑 Shutdown signal received. Cleaning up Hermes loop...");
-        // Additional cleanup like releasing global locks could go here
-        process.exit(0);
-    };
-
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-
-    isLooping = true;
-
-    while (isLooping) {
-        try {
-            if (Object.keys(agentStatusCache).length === 0) {
-                const diskStatus = readStatus();
-                agentStatusCache = diskStatus || {};
-            }
-
-            // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
-            const agentStatuses = readStatus();
-            let updatedStatus = false;
-            for (const [agentName, info] of Object.entries(agentStatuses)) {
-                const { state, lastUpdated, task } = info as { state: string; task: string; lastUpdated?: string };
-                if (state === "EXECUTING" && lastUpdated) {
-                    const lastUpdatedTime = Date.parse(lastUpdated);
-                    if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
-                        const displayAgent = agentName.startsWith("@") ? agentName : `@${agentName}`;
-                        UI.error(`⚠️  Agent ${displayAgent} has TIMED OUT (in EXECUTING state for >30m). Triggering Self-Healing...`);
-                        
-                        // SELF-HEALING: Log the failure and reset to READY
-                        agentStatuses[agentName] = { 
-                            state: "READY", 
-                            task: "Idle (Recovered from Timeout)", 
-                            lastUpdated: new Date().toISOString() 
-                        };
-                        
-                        UI.success(`✅ Hermes Self-Healing: ${displayAgent} reset to READY state. Task "${task}" aborted for recovery.`);
-                        updatedStatus = true;
-                    }
-                }
-            }
-            if (updatedStatus) {
-                updateDocumentStore("status", agentStatuses);
-                agentStatusCache = { ...agentStatuses }; // Sync cache
-            }
-
-            if (fs.existsSync(messagesDir)) {
-                const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
-                const pendingMessages: HermesMessage[] = [];
-                const fileMessagesMap: Record<string, HermesMessage[]> = {};
-                const acquiredLocks: string[] = [];
-
-                try {
-                    for (const file of messageFiles) {
-                        const agentName = file.replace(".json", "");
-
-                        const lockPath = path.join(messagesDir, `${agentName}.lock`);
-                        const locked = await acquireMessageLock(lockPath);
-                        if (!locked) {
-                            // Skip this file in this iteration if we cannot lock it to avoid race conditions
-                            continue;
-                        }
-                        acquiredLocks.push(lockPath);
-
-                        const filePath = path.join(messagesDir, file);
-                        try {
-                            const content = fs.readFileSync(filePath, "utf8").trim();
-                            if (!content) continue;
-                            const lines = content.split("\n");
-                            const allMsgs: HermesMessage[] = [];
-                            lines.forEach((line) => {
-                                if (!line.trim()) return;
-                                try {
-                                    const parsed = JSON.parse(line);
-                                    const msg = HermesMessageSchema.parse(parsed);
-
-                                    // Contract Validation for structured task messages
-                                    // ACTION & DELEGATION must be valid TaskRequest payloads
-                                    // SUBTASK must have a parentId and valid task payload
-                                    // ALERT must have a content string (free-form, no schema required)
-                                    if (msg.category === "ACTION" || msg.category === "DELEGATION") {
-                                        try {
-                                            const payload = JSON.parse(msg.content);
-                                            TaskRequestSchema.parse(payload);
-                                        } catch (e) {
-                                            UI.error(`Invalid task contract payload in ${msg.category} from @${msg.from}: ${(e as Error).message}`);
-                                            return; // Skip invalid message
-                                        }
-                                    }
-                                    if (msg.category === "SUBTASK") {
-                                        if (!msg.parentId) {
-                                            UI.error(`SUBTASK from @${msg.from} is missing required parentId — skipping.`);
-                                            return;
-                                        }
-                                        try {
-                                            const payload = JSON.parse(msg.content);
-                                            TaskRequestSchema.parse(payload);
-                                        } catch (e) {
-                                            UI.error(`Invalid SUBTASK payload from @${msg.from}: ${(e as Error).message}`);
-                                            return;
-                                        }
-                                    }
-                                    if (msg.category === "ALERT" && !msg.content.trim()) {
-                                        UI.error(`ALERT from @${msg.from} has empty content — skipping.`);
-                                        return;
-                                    }
-
-                                    // A message is actionable if it's pending, or if it's been approved.
-                                    if (msg.status === "PENDING" || msg.status === "APPROVED") {
-                                        pendingMessages.push(msg);
-                                    }
-                                    allMsgs.push(msg);
-                                } catch (e) {
-                                    UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
-                                }
-                            });
-                            fileMessagesMap[file] = allMsgs;
-                        } catch (err) {
-                            UI.error(`Error occurred while reading ${file}.`);
-                            logger.debug(`Failed to read message file ${file}`, err);
-                        }
-                    }
-
-                    if (pendingMessages.length > 0) {
-                        // Sort by priority: HIGH -> NORMAL -> LOW
-                        const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
-                        pendingMessages.sort((a, b) => {
-                            const pA = priorityOrder[a.priority || "NORMAL"] || 2;
-                            const pB = priorityOrder[b.priority || "NORMAL"] || 2;
-                            if (pA !== pB) return pA - pB;
-                            return Date.parse(a.timestamp) - Date.parse(b.timestamp);
-                        });
-
-                        UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
-
-                        const statusChanges: Record<string, { state: string; task: string }> = {};
-
-                        for (const msg of pendingMessages) {
-                            const { from, to, content, traceId, category, status, requiresApproval } = msg;
-
-                            // Approval Gate for high-risk actions.
-                            // If it requires approval but isn't approved yet, skip it for now.
-                            if ((category === "ACTION" || category === "ALERT") && requiresApproval && status !== "APPROVED") {
-                                logger.debug(`Action for @${to} (Trace: ${traceId}) is pending manager approval.`);
-                                continue;
-                            }
-                            
-                            // Gate for regular messages.
-                            // If it's a non-approval-required message, it should only be processed when PENDING.
-                            // This prevents re-processing of SUBTASK/REPLY messages that might get set to APPROVED.
-                            if (!(category === "ACTION" || category === "ALERT") && status !== "PENDING") {
-                                continue;
-                            }
-
-
-                            const isSubtask = category === "SUBTASK" || !!msg.parentId;
-                            const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
-
-                            UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
-
-                            let targetState = "EXECUTING";
-                            if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
-
-                            let taskDescription = content;
-                            if (category === "DELEGATION" || category === "ACTION") {
-                                try {
-                                    const payload = JSON.parse(content);
-                                    taskDescription = payload.task || content;
-                                } catch {
-                                    // Ignore
-                                }
-                            }
-
-                            statusChanges[to] = { state: targetState, task: taskDescription };
-
-                            if (targetState === "BRIEFED") {
-                                UI.success(`${to} informed and took over the task.`);
-                                statusChanges[to] = { state: "EXECUTING", task: taskDescription };
-                            }
-
-                            if (isSubtask) {
-                                UI.success(`Sub-task connection established (Parent: ${msg.parentId || "Unknown"}).`);
-                            }
-
-                            UI.success(`Collaboration initiated: ${from} -> ${to}`);
-
-                            msg.status = "PROCESSED";
-                        }
-
-                        applyBatchStatusUpdates(statusChanges);
-
-                        const archiveDir = path.join(messagesDir, "archive");
-                        
-                        for (const file of Object.keys(fileMessagesMap)) {
-                            const filePath = path.join(messagesDir, file);
-                            const msgs = fileMessagesMap[file];
-                            
-                            const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
-                            const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
-                            
-                            try {
-                                if (activeMsgs.length > 0) {
-                                    const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                                    writeTextFile(filePath, updatedContent);
-                                } else if (fs.existsSync(filePath)) {
-                                    writeTextFile(filePath, "");
-                                }
-
-                                if (processedMsgs.length > 0) {
-                                    if (!fs.existsSync(archiveDir)) {
-                                        fs.mkdirSync(archiveDir, { recursive: true });
-                                    }
-                                    const agentName = file.replace(".json", "");
-                                    const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
-                                    const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                                    appendFile(archivePath, archiveContent);
-                                    UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
-                                }
-                            } catch (err) {
-                                UI.error(`Error occurred while updating and archiving the message file ${file}.`);
-                                logger.debug(`Failed to update and archive message file ${file}`, err);
-                            }
-                        }
-                    }
-                } finally {
-                    for (const lockPath of acquiredLocks) {
-                        releaseMessageLock(lockPath);
-                    }
-                }
-            }
-        } catch (globalLoopErr) {
-            UI.error(`⚠️  Critical error in Hermes orchestration loop: ${(globalLoopErr as Error).message}`);
-            logger.debug("Hermes global loop failure", globalLoopErr);
-        }
-
-        iterationCount++;
-        // If maxIterations is set (e.g. in tests), stop after N iterations without sleeping
-        if (maxIterations !== undefined && iterationCount >= maxIterations) {
-            isLooping = false;
-            break;
-        }
-
-        // Prevent 100% CPU and provide breathing room for I/O
-        await sleep(2000);
-    }
-}
-
-/**
- * Standard tool for agents to delegate tasks to other agents.
- */
-export async function sendMessage(args: { 
-    from: string; 
-    to: string; 
-    category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT"; 
-    content: string; 
-    traceId: string;
-    parentId?: string;
-    priority?: "HIGH" | "NORMAL" | "LOW";
-    requiresApproval?: boolean;
-}) {
-    const frameworkDir = getFrameworkDir();
-    const messagesDir = path.join(frameworkDir, "messages");
-    const agentName = args.to.replace("@", "");
-    const messagePath = path.join(messagesDir, `${agentName}.json`);
-    const lockPath = path.join(messagesDir, `${agentName}.lock`);
-
-    let retries = 20; // Increased retries from 3 to 20
-    let acquired = false;
-    while (retries > 0) {
-        try {
-            if (fs.existsSync(lockPath)) {
-                try {
-                    const stats = fs.statSync(lockPath);
-                    // Increased stale lock timeout from 5s to 10s for heavy ops
-                    if (Date.now() - stats.mtimeMs > 10000) {
-                        UI.warning(`♻️  Stale Hermes lock detected for @${agentName}. Clearing lock for @${args.from}.`);
-                        const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
-                        fs.renameSync(lockPath, tempLockPath);
-                        fs.unlinkSync(tempLockPath);
-                    }
-                } catch (err) {
-                    logger.debug(`Failed to unlink stale Hermes lock for ${agentName} concurrently`, err);
-                }
-            }
-            if (!fs.existsSync(messagesDir)) {
-                fs.mkdirSync(messagesDir, { recursive: true });
-            }
-            fs.writeFileSync(lockPath, `Locked by ${args.from} at ${new Date().toISOString()}`, { flag: "wx" });
-            acquired = true;
-            break;
-        } catch (err: unknown) {
-            const error = err as { code?: string; message?: string };
-            if (error.code === "EEXIST") {
-                retries--;
-                if (retries > 0) {
-                    // Exponential backoff or jitter could be added here, 
-                    // but fixed 500ms is usually fine for local file locks.
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                }
-            } else {
-                UI.error(`Unexpected error occurred while acquiring the lock: ${error.message || String(err)}`);
-                break;
-            }
-        }
-    }
-
-    if (!acquired) {
-        UI.error(`Message could not be delivered: Hermes lock is busy. (${args.from} -> ${args.to})`);
-        return;
-    }
-
-    try {
-        const defaultPriority = (args.category === "ALERT" || args.category === "ACTION") ? "HIGH" : "NORMAL";
-        // Only ALERT requires manager approval by default.
-        // ACTION messages flow freely unless the caller explicitly sets requiresApproval=true.
-        // This prevents workflow blockage on normal agent-to-agent task delegation.
-        const requiresApproval = args.requiresApproval !== undefined
-            ? args.requiresApproval
-            : args.category === "ALERT";
-
-        const message: HermesMessage = {
-            timestamp: new Date().toISOString(),
-            priority: args.priority || defaultPriority,
-            ...args,
-            status: "PENDING",
-            requiresApproval: requiresApproval,
-        };
-        
-        appendFile(messagePath, JSON.stringify(message) + "\n");
-        
-        return message;
-    } catch (err) {
-        UI.error(`Message could not be delivered: ${args.from} -> ${args.to}`);
-        logger.debug(`Hermes sendMessage failed (${args.from} -> ${args.to})`, err);
-    } finally {
-        if (acquired && fs.existsSync(lockPath)) {
-            try {
-                fs.unlinkSync(lockPath);
-            } catch {
-                // Ignore delete errors if concurrently unlinked
-            }
-        }
-    }
-}
-
-
-function applyBatchStatusUpdates(changes: Record<string, { state: string; task: string }>) {
-    let hasChanges = false;
-    const now = new Date().toISOString();
-
-    for (const [agent, data] of Object.entries(changes)) {
-        const current = agentStatusCache[agent];
-        if (!current || current.state !== data.state || current.task !== data.task) {
-            agentStatusCache[agent] = { ...data, lastUpdated: now };
-            hasChanges = true;
-        }
-    }
-
-    if (hasChanges) {
-        updateDocumentStore("status", agentStatusCache);
-        logger.debug("In-memory status cache synced to disk.");
-    }
-}

package/src/cli/commands/plan.ts

@@ -1,113 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { generateULID } from "../utils/time.js";
-import { UI } from "../utils/ui.js";
-import { writeJsonFile } from "../utils/fs.js";
-
-/**
- * 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("💡  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("💡  Add .md files to docs/ with your project requirements.");
-        return;
-    }
-
-    UI.intent("Planning Engine", `Reading ${mdFiles.length} document(s) from docs/...`);
-
-    // Discover available template standards
-    const templatesDir = path.join(projectRoot, "templates");
-    const standards: string[] = [];
-    if (fs.existsSync(templatesDir)) {
-        const templateFiles = fs.readdirSync(templatesDir);
-        standards.push(...templateFiles.filter(f => f.endsWith("-standards.md")).map(f => `templates/${f}`));
-        if (standards.length > 0) {
-            UI.success(`Found ${standards.length} standard templates available for code generation.`);
-        }
-    }
-
-    let totalTasks = 0;
-
-    for (const file of mdFiles) {
-        const filePath = path.join(docsDir, file.name);
-        const content = fs.readFileSync(filePath, "utf8");
-        const lines = content.split("\n");
-        const traceId = generateULID();
-
-        UI.success(`📄 docs/${file.name} (${lines.length} lines) → Trace: ${traceId}`);
-
-        console.warn(`   Content preview: ${content.substring(0, 200).replace(/\n/g, " ")}...`);
-
-        // Extract headings as task descriptions
-        const headingRegex = /^#{2,4}\s+(.+)$/gm;
-        let headingCount = 0;
-        while (headingRegex.exec(content) !== null) {
-            headingCount++;
-            totalTasks++;
-        }
-
-        // Extract checklist items
-        const taskRegex = /- \[ \]\s+(.+)/g;
-        let taskMatch;
-        let taskCount = 0;
-        while ((taskMatch = taskRegex.exec(content)) !== null) {
-            if (taskMatch[1].trim().length >= 3) {
-                taskCount++;
-                totalTasks++;
-            }
-        }
-
-        console.warn(`   📋 ${headingCount} sections, ${taskCount} actionable tasks detected`);
-
-        // Store in project memory-compatible format
-        const memoryDir = path.join(projectRoot, ".atabey", "memory", "tasks");
-        if (!fs.existsSync(memoryDir)) {
-            fs.mkdirSync(memoryDir, { recursive: true });
-        }
-
-        const taskFile = path.join(memoryDir, `${traceId}.json`);
-        const taskData = {
-            traceId,
-            source: `docs/${file.name}`,
-            description: `Process requirements from docs/${file.name}`,
-            status: "PENDING",
-            createdAt: new Date().toISOString(),
-            standards,
-            headings: headingCount,
-            tasks: taskCount,
-            preview: content.substring(0, 500),
-        };
-        writeJsonFile(taskFile, taskData);
-    }
-
-    // Log available standards
-    if (standards.length > 0) {
-        console.warn("");
-        UI.divider();
-        console.warn("📚  Available Enterprise Standards:");
-        standards.forEach(s => console.warn(`    - ${s}`));
-        UI.divider();
-    }
-
-    UI.success(`\n✅ Planning complete: ${totalTasks} tasks identified from ${mdFiles.length} document(s).`);
-    console.warn("\n📋  Next steps:");
-    console.warn("    1. Run 'atabey status' to see project state");
-    console.warn("    2. AI agents (Claude, Gemini, Grok, etc.) will read docs/ and templates/");
-    console.warn("    3. Agents generate enterprise-standard code based on requirements");
-    console.warn("    4. Use @agent delegation for specific tasks: atabey @backend \"...\"");
-}

package/src/cli/commands/script.ts

@@ -1,20 +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: string, projectPath: string) {
-    const fullPath = path.join(targetDir, projectPath);
-    if (!fs.existsSync(fullPath)) {
-        console.warn(`❌ Project path not found: ${projectPath}`);
-        return;
-    }
-    console.warn(`🚀 Running 'npm run ${script}' in ${projectPath}...`);
-    try {
-        cp.spawnSync("npm", ["run", script], { cwd: fullPath, stdio: "inherit", shell: true });
-    } catch (e: unknown) {
-        const message = e instanceof Error ? e.message : "Unknown error";
-        console.warn(`❌ Failed to run script: ${message}`);
-    }
-}

package/src/cli/commands/security.ts

@@ -1,38 +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: string) {
-    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: string[] = [];
-    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("✅ No security issues detected.");
-    } else {
-        issues.forEach((issue) => console.warn(`⚠️  ${issue}`));
-    }
-}

package/src/cli/commands/status.ts

@@ -1,44 +0,0 @@
-import chalk from "chalk";
-import { listTasks, readState, readStatus } from "../utils/memory.js";
-
-/**
- * Print the current framework status.
- */
-export async function statusCommand() {
-    const state = readState();
-    const tasks = listTasks();
-    const agentStatuses = readStatus();
-
-    if (!state) {
-        console.error("❌ Error: Memory state not found. Please run 'init' first.");
-        return;
-    }
-
-    console.warn("\n📊 --- PROJECT STATUS ---");
-    console.warn(`🔹 Phase: ${state.phase}`);
-    console.warn(`🆔 Trace ID: ${state.traceId}`);
-    console.warn(`🤖 Manager: ${state.managerState}`);
-
-    // Read Agent Status from Document Store
-    console.warn("\n🎖️  Atabey Army Status (Agent States):");
-    for (const [agentName, info] of Object.entries(agentStatuses)) {
-        const { state, task } = info as { state: string; task: string };
-        let coloredState = state;
-        if (state === "READY") coloredState = chalk.green(state);
-        else if (state === "EXECUTING") coloredState = chalk.yellow(state);
-        else if (state === "BLOCKED" || state === "TIMEOUT") coloredState = chalk.red(state);
-        else if (state === "WAITING") coloredState = chalk.cyan(state);
-        
-        console.warn(`  ${chalk.bold(agentName.padEnd(12))} : [${coloredState}] - ${task}`);
-    }
-
-    if (tasks.length > 0) {
-        console.warn("\n📋 Active Tasks:");
-        tasks.forEach((t: { priority: string; status: string; description: string; agent: string }) => {
-            console.warn(`  - [${t.priority}] ${t.status}: ${t.description} (@${t.agent})`);
-        });
-    }
-
-    console.warn("\n-----------------------\n");
-}
-