agent-enderun 0.9.0 → 0.9.1

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");
+}

package/src/cli/commands/trace.ts

@@ -0,0 +1,46 @@
+import fs from "fs";
+
+import { getMemoryPath, acquireMemoryLock, releaseMemoryLock } from "../utils/memory.js";
+import { generateULID } from "../utils/time.js";
+import { sanitizeTableCell, normalizeAgentName, normalizePriority, insertTaskRow } from "../utils/string.js";
+
+/**
+ * Generate a new Trace ID and add it to project memory.
+ */
+export function traceNewCommand(description: string, agent = "manager", priority = "P2"): string | void {
+    const memoryPath = getMemoryPath();
+    if (!fs.existsSync(memoryPath)) {
+        console.error("❌ Error: PROJECT_MEMORY.md not found.");
+        return;
+    }
+
+    const traceId = generateULID();
+    const safeDescription = sanitizeTableCell(description);
+    const safeAgent = normalizeAgentName(agent);
+    const safePriority = normalizePriority(priority);
+    const newTask = `| ${traceId} | ${safeDescription} | @${safeAgent} | ${safePriority} | IN_PROGRESS |`;
+    const lockPath = `${memoryPath}.lock`;
+
+    if (!acquireMemoryLock(lockPath)) {
+        console.error("❌ Error: Memory lock timeout (5 retries).");
+        return;
+    }
+
+    try {
+        const content = fs.readFileSync(memoryPath, "utf8");
+        const updated = insertTaskRow(content, newTask);
+        if (!updated) {
+            console.error("❌ Error: ACTIVE TASKS table not found, task could not be added.");
+            return;
+        }
+
+        fs.writeFileSync(memoryPath, updated);
+        console.warn(`
+✅ New Trace ID created: ${traceId}`);
+        console.warn(`📝 Added to task list: ${description}
+`);
+        return traceId;
+    } finally {
+        releaseMemoryLock(lockPath);
+    }
+}

package/src/cli/index.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { getPackageVersion } from "./utils/pkg.js";
+import { initCommand } from "./commands/init.js";
+import { checkCommand } from "./commands/check.js";
+import { statusCommand } from "./commands/status.js";
+import { traceNewCommand } from "./commands/trace.js";
+import { updateProjectMemoryCommand } from "./commands/memory.js";
+import { createAppCommand } from "./commands/app.js";
+import { verifyApiContractCommand } from "./commands/contract.js";
+import { orchestrateCommand } from "./commands/orchestrate.js";
+
+/**
+ * Main CLI entry point.
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+
+    switch (command) {
+    case "init":
+        await initCommand(args[1]);
+        break;
+
+    case "check":
+        checkCommand();
+        break;
+
+    case "status":
+        statusCommand();
+        break;
+
+    case "trace:new": {
+        const description = args[1] || "Default task";
+        const agent = args[2] || "manager";
+        const priority = args[3] || "P1";
+        traceNewCommand(description, agent, priority);
+        break;
+    }
+
+    case "update_project_memory": {
+        const section = args[1];
+        const content = args[2];
+        if (!section || !content) {
+            console.error("❌ Error: section and content are required.");
+            process.exit(64);
+        }
+        updateProjectMemoryCommand(section, content);
+        break;
+    }
+
+    case "create-app":
+        await createAppCommand(args.slice(1));
+        break;
+
+    case "orchestrate":
+    case "loop":
+        orchestrateCommand();
+        break;
+
+    case "verify-contract":
+        verifyApiContractCommand();
+        break;
+
+    case "version":
+    case "-v":
+    case "--version":
+        console.log(`v${getPackageVersion()}`);
+        break;
+
+    case "help":
+    case "-h":
+    case "--help":
+    default:
+        console.log(`
+🤖 Agent Enderun CLI — Enterprise AI Orchestration
+
+Usage:
+  agent-enderun <command> [options]
+
+Commands:
+  init [adapter]      Initialize Agent Enderun framework (gemini, claude, grok, etc.)
+  check               Perform an enterprise-grade system health check
+  status              Show active phase, trace ID, and agent statuses
+  trace:new <desc>    Start a new task chain with a unique Trace ID
+  create-app <idea>   Generate a new full-stack app from natural language
+  orchestrate         Start the dynamic Hermes agent orchestration loop
+  verify-contract     Validate type alignment between backend and frontend
+  version             Show version information
+
+Supported adapters (one init per IDE — separate folder each):
+  - gemini       → .enderun/ (SSOT) + gemini.md
+  - claude       → .enderun/ (SSOT) + claude.md
+  - grok         → .enderun/ (SSOT) + grok.md
+  - antigravity  → .enderun/ (SSOT) + agent.md
+
+Example:
+  agent-enderun init gemini
+  agent-enderun check
+  agent-enderun status
+  agent-enderun trace:new "Auth module design" backend P1
+      `);
+        break;
+    }
+}
+
+main().catch(console.error);