agent-enderun 0.9.0 → 0.9.2

package/src/cli/commands/init.ts

@@ -0,0 +1,272 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+import {
+    resolveAdapter,
+    isAdapterShimFile,
+    remapFrameworkContent,
+    runAdapterPostInit,
+    type AdapterConfig,
+} from "../adapters.js";
+import { getPackageManager, mergePackageJson, deepCleanProtocols, sanitizeJson, getPackageVersion } from "../utils/pkg.js";
+import { updateGitIgnore, ensureDir, writeJsonFile, copyDir } from "../utils/fs.js";
+import { initializeMemory } from "../utils/memory.js";
+import { checkCommand } from "./check.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const sourceDir = path.join(__dirname, "../../..");
+const targetDir = process.cwd();
+
+const FRAMEWORK_VERSION = getPackageVersion();
+
+const CORE_FILES = [
+    ".enderun",
+    "mcp.json",
+    ".env.example",
+    "ENDERUN.md",
+    "package.json",
+    "tsconfig.json",
+    "panda.config.ts",
+    "vitest.config.ts",
+    "framework-mcp",
+    "docs",
+    "eslint.config.js",
+];
+
+const FRAMEWORK_SUBDIRS = [
+    "agents",
+    "agents/schema",
+    "skills",
+    "knowledge",
+    "benchmarks",
+    "monitoring",
+    "logs",
+    "messages",
+    "memory-graph",
+    "memory-graph/agent-contexts",
+    "queue",
+    "queue/pending",
+    "queue/processing",
+    "queue/completed",
+    "queue/failed",
+    "queue/pipelines",
+];
+
+function buildDirsToCreate(adapter: AdapterConfig): string[] {
+    const dirs = [
+        adapter.frameworkDir,
+        ...FRAMEWORK_SUBDIRS.map((d) => `${adapter.frameworkDir}/${d}`),
+        "apps/web",
+        "apps/backend",
+        "docs",
+        "framework-mcp",
+        "tests",
+    ];
+    if (adapter.nestedDirs) {
+        for (const nested of adapter.nestedDirs) {
+            dirs.push(`${adapter.frameworkDir}/${nested}`);
+        }
+    }
+    return [...new Set(dirs)];
+}
+
+/**
+ * Scaffold the framework for a specific IDE adapter (separate runtime folder per IDE).
+ */
+export async function initCommand(adapterInput?: string) {
+    const adapter = resolveAdapter(adapterInput);
+    const { frameworkDir, shimFile, templateDir } = adapter;
+    const targetFrameworkDir = path.join(targetDir, frameworkDir);
+
+    console.warn(`🚀 Installing Agent Enderun (Adapter: ${adapter.id} → ${frameworkDir}/)...`);
+
+    if (!fs.existsSync(targetFrameworkDir)) {
+        fs.mkdirSync(targetFrameworkDir, { recursive: true });
+    }
+
+    for (const dir of buildDirsToCreate(adapter)) {
+        const fullPath = path.join(targetDir, dir);
+        if (!fs.existsSync(fullPath)) {
+            fs.mkdirSync(fullPath, { recursive: true });
+            console.warn(`📂 Created directory: ${dir}`);
+        }
+    }
+
+    const filesToProcess = [
+        ...CORE_FILES,
+        shimFile,
+    ].filter(
+        (f) =>
+            CORE_FILES.includes(f) ||
+      f === shimFile ||
+      fs.existsSync(path.join(sourceDir, f)),
+    );
+
+    ensureDir(path.join(targetDir, "apps/backend"));
+    const initContractPath = path.join(targetDir, "apps/backend/contract.version.json");
+    if (!fs.existsSync(initContractPath)) {
+        writeJsonFile(initContractPath, {
+            contract_hash: "initial_hash_placeholder",
+            last_updated: new Date().toISOString(),
+        });
+    }
+
+    let targetPkg: Record<string, unknown> = {};
+    try {
+        const targetPkgPath = path.join(targetDir, "package.json");
+        if (fs.existsSync(targetPkgPath)) {
+            targetPkg = JSON.parse(fs.readFileSync(targetPkgPath, "utf8"));
+        }
+    } catch {
+    // ignore
+    }
+
+    const pkgName = typeof targetPkg.name === "string" ? targetPkg.name : "";
+    const targetScope = pkgName
+        ? pkgName.startsWith("@")
+            ? pkgName.split("/")[0]
+            : `@${pkgName}`
+        : `@${path.basename(targetDir)}`;
+
+    for (const item of filesToProcess) {
+        const src = path.join(sourceDir, item);
+        let dest = path.join(targetDir, item);
+
+        if (item === "framework-mcp" && fs.existsSync(dest)) {
+            try {
+                fs.rmSync(dest, { recursive: true, force: true });
+            } catch {
+                // ignore
+            }
+        }
+
+        if (item === templateDir || item.startsWith(`${templateDir}/`)) {
+            dest = path.join(targetDir, item.replace(templateDir, frameworkDir));
+        }
+        if (item === "ENDERUN.md") {
+            dest = path.join(targetFrameworkDir, "ENDERUN.md");
+        }
+        if (isAdapterShimFile(item)) {
+            dest = path.join(targetDir, item);
+        }
+
+        if (!fs.existsSync(src)) {
+            continue;
+        }
+
+        if (fs.lstatSync(src).isDirectory()) {
+            const skipFiles =
+        item === templateDir ? ["logs", "PROJECT_MEMORY.md", "PROJECT_MEMORY.lock"] : [];
+            const nonDestructive = ["docs", templateDir].includes(item);
+            copyDir(
+                src,
+                dest,
+                new Set(skipFiles),
+                nonDestructive,
+                frameworkDir,
+                targetScope,
+                sanitizeJson,
+                adapter.id,
+            );
+        } else {
+            if (item === "package.json") continue;
+
+            if (fs.existsSync(dest) && !isAdapterShimFile(item)) {
+                console.warn(`ℹ️  Skipping existing file: ${item}`);
+                continue;
+            }
+
+            const ext = path.extname(item);
+            const textExtensions = [".md", ".json", ".js", ".ts", ".txt", ""];
+            if (textExtensions.includes(ext)) {
+                let content = fs.readFileSync(src, "utf8");
+                content = remapFrameworkContent(content, frameworkDir, adapter.id);
+
+                if (ext === ".json") {
+                    try {
+                        const json = JSON.parse(content);
+                        content = JSON.stringify(sanitizeJson(json, targetScope), null, 2);
+                        content = remapFrameworkContent(content, frameworkDir, adapter.id);
+                    } catch {
+                        content = content.replace(/workspace:[^"'\s]*/g, "*");
+                    }
+                }
+
+                fs.writeFileSync(dest, content);
+            } else {
+                fs.copyFileSync(src, dest);
+            }
+        }
+        console.warn(`✅ ${item} processed -> ${path.relative(targetDir, dest)}`);
+    }
+
+    mergePackageJson(path.join(targetDir, "package.json"), path.join(sourceDir, "package.json"));
+    updateGitIgnore(path.join(targetDir, ".gitignore"), frameworkDir);
+
+    const finalMemoryPath = path.join(targetFrameworkDir, "PROJECT_MEMORY.md");
+    initializeMemory(finalMemoryPath, frameworkDir);
+
+    deepCleanProtocols(targetDir, targetScope);
+
+    const sampleTestPath = path.join(targetDir, "tests/initial.test.ts");
+    if (!fs.existsSync(sampleTestPath)) {
+        fs.writeFileSync(
+            sampleTestPath,
+            `import { describe, it, expect } from "vitest";
+
+describe("Initial Setup", () => {
+  it("should verify the testing environment is active", () => {
+    expect(true).toBe(true);
+  });
+});
+`,
+        );
+    }
+
+    if (!fs.existsSync(path.join(targetDir, ".git"))) {
+        try {
+            execSync("git init", { cwd: targetDir, stdio: "ignore" });
+            console.warn("✅ Git repository initialized.");
+        } catch {
+            // ignore
+        }
+    }
+
+    console.warn(`\n🛠️  Running ${adapter.id} adapter configuration...`);
+    runAdapterPostInit(adapter, targetDir);
+
+    console.warn(`\n♊ ${adapter.id.toUpperCase()}: Setup complete.`);
+    console.warn(`   • Framework runtime: ${frameworkDir}/`);
+    console.warn(`   • Entrypoint shim: ${shimFile}`);
+    if (adapter.nestedDirs?.length) {
+        console.warn(`   • Nested: ${adapter.nestedDirs.map((d) => `${frameworkDir}/${d}/`).join(", ")}`);
+    }
+
+    const pkgMgr = getPackageManager();
+    const installCmd = pkgMgr === "npm" ? "npm install" : `${pkgMgr} install`;
+    const buildCmd = pkgMgr === "npm" ? "npm run enderun:build" : `${pkgMgr} run enderun:build`;
+
+    console.warn(`\n✨ Framework scaffolded! (v${FRAMEWORK_VERSION})`);
+
+    if (process.env.ENDERUN_SKIP_INSTALL === "1") {
+        console.warn("\n⏭️  Skipping install steps (ENDERUN_SKIP_INSTALL=1).");
+        return;
+    }
+
+    try {
+        execSync(installCmd, { stdio: "inherit" });
+        console.warn(`\n🏗️  Step 2/3: Running '${buildCmd}'...`);
+        execSync(buildCmd, { stdio: "inherit" });
+        console.warn("\n🔍 Step 3/3: Running 'agent-enderun check'...");
+        checkCommand();
+        console.warn("\n🚀 Agent Enderun is fully installed and verified!");
+    } catch (e: unknown) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.error("\n❌ Automatic installation failed. Run manually:");
+        console.warn(`👉 ${installCmd} && ${buildCmd}`);
+        console.error(message);
+    }
+}

package/src/cli/commands/knowledge.ts

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+
+import { getFrameworkDir } from "../utils/memory.js";
+
+const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
+
+export function updateKnowledgeBaseCommand(topic: string, content: string) {
+    if (!topic || !content) {
+        console.error("❌ Usage: agent-enderun update_knowledge_base <topic> <content>");
+        return;
+    }
+    const frameworkDir = getFrameworkDir();
+    const kbDir = path.join(targetDir, frameworkDir, "knowledge");
+    if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
+    const fileName = topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md";
+    fs.writeFileSync(path.join(kbDir, fileName), content);
+    console.warn(`✅ Knowledge base updated: ${topic}`);
+}
+
+export function searchKnowledgeBaseCommand(query: string) {
+    if (!query) {
+        console.error("❌ Usage: agent-enderun search_knowledge_base <query>");
+        return;
+    }
+    const frameworkDir = getFrameworkDir();
+    const kbDir = path.join(targetDir, 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/src/cli/commands/lint.ts

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

package/src/cli/commands/log.ts

@@ -0,0 +1,37 @@
+import fs from "fs";
+import path from "path";
+
+import { getFrameworkDir } from "../utils/memory.js";
+import { normalizeAgentName } from "../utils/string.js";
+
+const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
+
+export function logAgentActionCommand(data: { agent?: unknown; action?: string; requestId?: string; status?: string; summary?: string; files?: string[]; details?: Record<string, unknown> }) {
+    const frameworkDir = getFrameworkDir();
+    const logsDir = path.join(targetDir, frameworkDir, "logs");
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+
+    const agent = normalizeAgentName(data.agent);
+    const logPath = path.join(logsDir, `${agent}.json`);
+    let logs: Record<string, unknown>[] = [];
+
+    if (fs.existsSync(logPath)) {
+        try {
+            logs = JSON.parse(fs.readFileSync(logPath, "utf8"));
+            if (!Array.isArray(logs)) logs = [];
+        } catch {
+            logs = [];
+        }
+    }
+
+    const newEntry = {
+        timestamp: new Date().toISOString(),
+        ...data,
+    };
+
+    logs.push(newEntry);
+    fs.writeFileSync(logPath, JSON.stringify(logs, null, 2));
+    console.warn(`✅ Logged action to ${frameworkDir}/logs/${agent}.json`);
+}

package/src/cli/commands/memory.ts

@@ -0,0 +1,78 @@
+import fs from "fs";
+import path from "path";
+
+import { getMemoryPath, acquireMemoryLock, releaseMemoryLock } from "../utils/memory.js";
+
+export function updateProjectMemoryCommand(section: string, content: string) {
+    const memoryPath = getMemoryPath();
+    if (!fs.existsSync(memoryPath)) {
+        console.error("❌ Error: PROJECT_MEMORY.md not found.");
+        return;
+    }
+
+    const lockPath = `${memoryPath}.lock`;
+    if (!acquireMemoryLock(lockPath)) {
+        console.error("❌ Error: Memory lock timeout.");
+        return;
+    }
+
+    try {
+        let memoryContent = fs.readFileSync(memoryPath, "utf8");
+
+        if (section === "HISTORY") {
+            const headers = ["## HISTORY (Persistent Memory)", "## HISTORY"];
+            let sectionIndex = -1;
+            for (const h of headers) {
+                sectionIndex = memoryContent.indexOf(h);
+                if (sectionIndex !== -1) {
+                    break;
+                }
+            }
+
+            if (sectionIndex === -1) {
+                console.error("❌ Error: HISTORY section not found.");
+                return;
+            }
+            const headerEnd = memoryContent.indexOf("\n", sectionIndex) + 1;
+            memoryContent =
+                memoryContent.slice(0, headerEnd) +
+                `\n${content.trim()}\n` +
+                memoryContent.slice(headerEnd);
+
+            // --- Auto-Prune Logic ---
+            const historySplit = memoryContent.split("### ");
+            if (historySplit.length > 11) { // Title + 10 entries
+                const frameworkDir = path.dirname(memoryPath);
+                const archiveDir = path.join(frameworkDir, "archive/history");
+                if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+
+                const toArchive = historySplit.slice(11); // Keep the first 10 entries (newest)
+                const preserved = historySplit.slice(0, 11);
+                
+                const archiveContent = "### " + toArchive.join("### ");
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                fs.writeFileSync(path.join(archiveDir, `history-${timestamp}.md`), archiveContent);
+                
+                memoryContent = preserved.join("### ").trim() + "\n";
+                console.warn(`📦 Auto-Pruned: ${toArchive.length} old entries moved to archive.`);
+            }
+            // ------------------------
+        } else {
+            const escaped = section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`, "m");
+            if (!sectionRegex.test(memoryContent)) {
+                console.error(`❌ Error: Section not found: ${section}`);
+                return;
+            }
+            memoryContent = memoryContent.replace(
+                sectionRegex,
+                `## ${section}\n\n${content.trim()}\n`,
+            );
+        }
+
+        fs.writeFileSync(memoryPath, memoryContent);
+        console.warn(`✅ Section ${section} updated in PROJECT_MEMORY.md`);
+    } finally {
+        releaseMemoryLock(lockPath);
+    }
+}

package/src/cli/commands/orchestrate.ts

@@ -0,0 +1,111 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { getFrameworkDir } from "../utils/memory.js";
+
+interface HermesMessage {
+  timestamp: string;
+  from: string;
+  to: string;
+  category: "ACTION" | "DELEGATION" | "INFO" | "ALERT";
+  traceId: string;
+  content: string;
+  status: "PENDING" | "PROCESSED";
+}
+
+/**
+ * Start the live Hermes Orchestration & Message Loop
+ */
+export function orchestrateCommand() {
+  const frameworkDir = getFrameworkDir();
+  const messagesDir = path.join(process.cwd(), frameworkDir, "messages");
+  const statusPath = path.join(process.cwd(), frameworkDir, "STATUS.md");
+
+  console.log(`\n================================================================`);
+  console.log(`🏛️  AGENT ENDERUN — DYNAMIC HERMES ORCHESTRATÖR DÖNGÜSÜ`);
+  console.log(`================================================================`);
+  console.log(`🛰️  Hermes Message Broker dinleniyor: ${frameworkDir}/messages/...`);
+
+  if (!fs.existsSync(messagesDir)) {
+    fs.mkdirSync(messagesDir, { recursive: true });
+  }
+
+  // Scan all JSON files in the messages directory
+  const messageFiles = fs.readdirSync(messagesDir).filter(f => f.endsWith(".json"));
+  const pendingMessages: HermesMessage[] = [];
+
+  for (const file of messageFiles) {
+    const filePath = path.join(messagesDir, file);
+    try {
+      const content = fs.readFileSync(filePath, "utf8").trim();
+      if (!content) continue;
+      // Messages are stored as newline-delimited JSON
+      const lines = content.split("\n");
+      lines.forEach((line, index) => {
+        if (!line.trim()) return;
+        const msg = JSON.parse(line) as HermesMessage;
+        if (msg.status === "PENDING") {
+          pendingMessages.push(msg);
+        }
+      });
+    } catch (e) {
+      // ignore malformed lines
+    }
+  }
+
+  if (pendingMessages.length === 0) {
+    console.log(`\n🟢 Kuyruk Temiz: İşlenecek aktif Hermes mesajı bulunamadı.`);
+    console.log(`💡 İpucu: Bir uzman ajanı tetiklemek için send_agent_message aracını kullanın.`);
+    return;
+  }
+
+  console.log(`\n📥 Kuyrukta ${pendingMessages.length} adet bekleyen Hermes mesajı tespit edildi:\n`);
+
+  // Process the first pending message
+  const activeMessage = pendingMessages[0];
+  const toAgent = activeMessage.to;
+  const fromAgent = activeMessage.from;
+
+  console.log(`✉️  [GÖNDEREN]   : ${fromAgent}`);
+  console.log(`📥 [ALICI]      : ${toAgent}`);
+  console.log(`🆔 [TRACE ID]   : ${activeMessage.traceId}`);
+  console.log(`🏷️  [KATEGORİ]   : ${activeMessage.category}`);
+  console.log(`💬 [MESAJ]      : "${activeMessage.content}"`);
+  console.log(`----------------------------------------------------------------`);
+
+  // 1. Transition the target agent state to EXECUTING in STATUS.md
+  console.log(`⏳ Ajan Durum Geçişi: ${toAgent} durumu EXECUTING olarak kilitleniyor...`);
+  transitionAgentState(statusPath, toAgent, "EXECUTING", activeMessage.content);
+
+  console.log(`\n🤖 Görev Devredildi!`);
+  console.log(`👉 Lütfen ${toAgent} agent talimatlarını (${frameworkDir}/agents/${toAgent.replace("@", "")}.md) okuyun ve görevi yerine getirin.`);
+  console.log(`💡 Görev tamamlandığında, mesajı PROCESSED olarak işaretlemek ve ajanı boşa çıkarmak için:`);
+  console.log(`   npx agent-enderun status komutuyla kontrol edin.`);
+}
+
+function transitionAgentState(statusPath: string, agent: string, state: string, task: string) {
+  if (!fs.existsSync(statusPath)) return;
+  try {
+    let content = fs.readFileSync(statusPath, "utf8");
+    const lines = content.split("\n");
+    const targetName = agent;
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(`| ${targetName} |`)) {
+        // e.g., | @backend | IDLE | — | — | 9.2/10 | — |
+        const parts = lines[i].split("|");
+        if (parts.length >= 7) {
+          parts[2] = ` ${state} `;
+          parts[3] = ` ${task.slice(0, 20)}... `;
+          lines[i] = parts.join("|");
+          break;
+        }
+      }
+    }
+
+    fs.writeFileSync(statusPath, lines.join("\n"));
+    console.log(`✅ STATUS.md üzerinde ${agent} durumu başarıyla '${state}' yapıldı.`);
+  } catch (e) {
+    console.error("❌ STATUS.md güncellenirken hata oluştu:", e);
+  }
+}

package/src/cli/commands/script.ts

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

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+
+import { collectFiles } from "../utils/fs.js";
+
+const targetDir = process.cwd();
+
+export 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

@@ -0,0 +1,59 @@
+import fs from "fs";
+
+import { getMemoryPath, getFrameworkDir } from "../utils/memory.js";
+
+/**
+ * Print the current framework status.
+ */
+export function statusCommand() {
+    const memoryPath = getMemoryPath();
+    const frameworkDir = getFrameworkDir();
+    if (!fs.existsSync(memoryPath)) {
+        console.error(`❌ Error: ${frameworkDir}/PROJECT_MEMORY.md not found. Please run 'init' first.`);
+        return;
+    }
+
+    const content = fs.readFileSync(memoryPath, "utf8");
+    
+    // Format 1: Table Style (Original)
+    const tableMatch = content.match(
+        /\| Active Phase \| Profile \| Last Update \| Active Trace ID \| Blockers \|\n\| :----------- \| :------ \| :---------- \| :-------------- \| :------- \|\n\| (.*?) \| (.*?) \| (.*?) \| (.*?) \| (.*?) \|/,
+    );
+
+    // Format 2: List Style (New)
+    const phaseMatch = content.match(/- Phase: (.*)/);
+    const traceIdMatch = content.match(/- Trace ID: (.*)/);
+    const profileMatch = content.match(/- Profile: (.*)/);
+    const updateMatch = content.match(/- Last Update: (.*)/);
+    const blockersMatch = content.match(/- Blockers: (.*)/);
+
+    console.warn("\n📊 --- PROJECT STATUS ---");
+    
+    if (tableMatch) {
+        console.warn(`🔹 Phase: ${tableMatch[1].trim()}`);
+        console.warn(`🧭 Profile: ${tableMatch[2].trim()}`);
+        console.warn(`📅 Update: ${tableMatch[3].trim()}`);
+        console.warn(`🆔 Trace ID: ${tableMatch[4].trim()}`);
+        console.warn(`⛔ Blockers: ${tableMatch[5].trim()}`);
+    } else if (phaseMatch || traceIdMatch) {
+        if (phaseMatch) console.warn(`🔹 Phase: ${phaseMatch[1].trim()}`);
+        if (profileMatch) console.warn(`🧭 Profile: ${profileMatch[1].trim()}`);
+        if (updateMatch) console.warn(`📅 Update: ${updateMatch[1].trim()}`);
+        if (traceIdMatch) console.warn(`🆔 Trace ID: ${traceIdMatch[1].trim()}`);
+        if (blockersMatch) console.warn(`⛔ Blockers: ${blockersMatch[1].trim()}`);
+        
+        // Check for manager state in list style
+        const managerState = content.match(/- @manager state: (.*)/);
+        if (managerState) console.warn(`🤖 Manager: ${managerState[1].trim()}`);
+    } else {
+        console.warn("⚠️  Status data could not be parsed in standard formats.");
+    }
+
+    const tasksSection = content.match(/## ACTIVE TASKS\n\n([\s\S]*?)(?=\n##|$)/);
+    if (tasksSection) {
+        console.warn("\n📋 Active Tasks:");
+        console.warn(tasksSection[1].trim());
+    }
+
+    console.warn("\n-----------------------\n");
+}