agent-enderun 0.1.10 → 0.2.1

package/bin/cli.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-console.log("🤖 Agent Enderun CLI — Initializing...");
 
 import fs from "fs";
 import path from "path";
@@ -177,12 +176,12 @@ function mergePackageJson(targetPath, sourcePath) {
 function updateGitIgnore(targetPath, frameworkDir = ".enderun") {
   const IGNORE_LINES = [
     "# AI-Enderun",
-    ".gemini/logs/*.json",
+    ".enderun/logs/*.json",
     ".claude/logs/*.json",
     ".cursor/logs/*.json",
     ".codex/logs/*.json",
     ".enderun/logs/*.json",
-    ".gemini/*.lock",
+    ".enderun/*.lock",
     ".claude/*.lock",
     ".cursor/*.lock",
     ".codex/*.lock",
@@ -312,35 +311,37 @@ async function initCommand(selectedAdapter) {
   };
 
   const targetBase = selectedAdapter ? `.${selectedAdapter}` : ".enderun";
+
   const targetFrameworkDir = path.join(targetDir, targetBase);
 
   const CORE_FILES = [
     ".enderun",
-    "docs",
+    
     "mcp.json",
     ".env.example",
     "ENDERUN.md",
-    ".enderun/cli-commands.json",
-    ".enderun/config.json",
-    ".enderun/STATUS.md",
+    "package.json",
     "packages/framework-mcp",
     "packages/shared-types",
-    "panda.config.ts",
   ];
 
   const DIRS_TO_CREATE = [
+    targetBase,
     `${targetBase}/agents`,
     `${targetBase}/docs/api`,
+    `${targetBase}/knowledge`,
+    `${targetBase}/benchmarks`,
+    `${targetBase}/monitoring`,
     `${targetBase}/logs`,
     `${targetBase}/messages`,
     "apps/web",
     "apps/backend",
-    "docs",
+    
     "packages/shared-types",
     "packages/framework-mcp",
   ];
 
-  console.log("🚀 Installing Agent Enderun (Smart Mode)...");
+  console.log(`🚀 Installing Agent Enderun (Adapter: ${selectedAdapter || "all"})...`);
 
   // Ensure target framework base exists
   if (!fs.existsSync(targetFrameworkDir)) {
@@ -357,13 +358,12 @@ async function initCommand(selectedAdapter) {
   }
 
   let filesToProcess = [...CORE_FILES];
-  
   if (selectedAdapter) {
     if (!ADAPTERS[selectedAdapter]) {
       console.error(`❌ Invalid adapter: ${selectedAdapter}. Available: gemini, claude, cursor, codex`);
       process.exit(1);
     }
-    filesToProcess = [...CORE_FILES, ...ADAPTERS[selectedAdapter]];
+    filesToProcess.push(...ADAPTERS[selectedAdapter]);
   } else {
     Object.values(ADAPTERS).forEach(list => filesToProcess.push(...list));
   }
@@ -387,7 +387,7 @@ async function initCommand(selectedAdapter) {
     let dest = path.join(targetDir, item);
     
     // FORCED CLEANUP: Delete existing framework directories in target before copying
-    if (["packages/framework-mcp", "packages/shared-types", ".enderun", ".gemini", ".claude"].includes(item)) {
+    if (["packages/framework-mcp", "packages/shared-types", ".enderun", ".enderun", ".claude", ".cursor", ".codex"].includes(item)) {
       if (fs.existsSync(dest)) {
         try {
           fs.rmSync(dest, { recursive: true, force: true });
@@ -397,38 +397,27 @@ async function initCommand(selectedAdapter) {
       }
     }
 
-    // Clean up existing lockfiles in target
-    if (fs.existsSync(dest)) {
-      const lockFile = path.join(dest, "package-lock.json");
-      if (fs.existsSync(lockFile)) {
-        fs.unlinkSync(lockFile);
-      }
-    }
-    
     // Remap core framework files to targetBase
     if (item === ".enderun" || item.startsWith(".enderun/")) {
       dest = path.join(targetDir, item.replace(".enderun", targetBase));
     }
     if (item === "ENDERUN.md") dest = path.join(targetFrameworkDir, "ENDERUN.md");
-    if (ADAPTERS[selectedAdapter]?.includes(item)) {
-      dest = path.join(targetDir, item); // Keep adapter linker files in root
+    
+    // Check if item is an adapter pointer file
+    const isAdapterPointer = Object.values(ADAPTERS).flat().includes(item);
+    if (isAdapterPointer) {
+      dest = path.join(targetDir, item);
     }
 
     if (fs.existsSync(src)) {
       if (fs.lstatSync(src).isDirectory()) {
-        // When copying framework dir, skip logs and project-specific state
-        const skipFiles = (item === ".enderun") ? ["logs", "PROJECT_MEMORY.md", "BRAIN_DASHBOARD.md", "PROJECT_MEMORY.lock"] : [];
+        const skipFiles = (item === ".enderun") ? ["logs", "PROJECT_MEMORY.md", "PROJECT_MEMORY.lock"] : [];
         const isDocs = item === "docs";
         copyDir(src, dest, new Set(skipFiles), isDocs, targetBase, targetScope);
       } else {
-        // Special files handling
-        if (item === "package.json") continue;
-        if (item === "ENDERUN.md" && fs.existsSync(dest)) {
-          console.log(`ℹ️  Skipping ENDERUN.md (already exists in ${targetBase}).`);
-          continue;
-        }
+        if (item === "package.json") continue; // We merge it later
         
-        if (fs.existsSync(dest)) {
+        if (fs.existsSync(dest) && !isAdapterPointer) {
           console.log(`ℹ️  Skipping existing file: ${item}`);
           continue;
         }
@@ -440,16 +429,16 @@ async function initCommand(selectedAdapter) {
           content = content.replace(/\{\{FRAMEWORK_DIR\}\}/g, targetBase);
           content = content.replace(/\{\{ADAPTER\}\}/g, selectedAdapter || "enderun");
           
-          // Sanitize workspace: protocol in all text files
           if (ext === ".json") {
             try {
               const json = JSON.parse(content);
               content = JSON.stringify(sanitizeJson(json, targetScope), null, 2);
+              // Ensure variable replacement even inside JSON strings if any
+              content = content.replace(/\{\{FRAMEWORK_DIR\}\}/g, targetBase);
+              content = content.replace(/\{\{ADAPTER\}\}/g, selectedAdapter || "enderun");
             } catch (e) {
               content = content.replace(/workspace:[^"'\s]*/g, "*");
             }
-          } else {
-            content = content.replace(/workspace:[^"'\s]*/g, "*");
           }
           
           fs.writeFileSync(dest, content);
@@ -461,84 +450,63 @@ async function initCommand(selectedAdapter) {
     }
   }
 
-  // Smart setup
+  // Merge Package JSON
   mergePackageJson(path.join(targetDir, "package.json"), path.join(sourceDir, "package.json"));
   updateGitIgnore(path.join(targetDir, ".gitignore"), targetBase);
   
   const finalMemoryPath = path.join(targetDir, targetBase, "PROJECT_MEMORY.md");
   initializeMemory(finalMemoryPath, targetBase);
   
-  // Deep clean ALL package.json files in target directory (removes workspace: and unocss)
   deepCleanProtocols(targetDir, targetScope);
 
-  // Initialize git if missing
   if (!fs.existsSync(path.join(targetDir, ".git"))) {
     try {
       const { execSync } = await import("child_process");
       execSync("git init", { cwd: targetDir, stdio: "ignore" });
       console.log("✅ Git repository initialized.");
-    } catch (e) {
-      console.warn("⚠️  Could not initialize git automatically. Please run 'git init' manually.");
-    }
+    } catch (e) {}
   }
 
-  // --- Post-Install Hooks (Smart Setup) ---
-  
   console.log("\n🛠️  Running smart configuration for adapters...");
 
-  // Universal Gemini Compatibility (Symlink)
-  try {
-    const geminiDir = path.join(targetDir, ".gemini");
-    const geminiAgentsDir = path.join(geminiDir, "agents");
-    const frameworkAgentsDir = path.join(targetDir, targetBase, "agents");
 
-    if (!fs.existsSync(geminiDir)) {
-      fs.mkdirSync(geminiDir, { recursive: true });
-    }
-
-    if (targetBase !== ".gemini" && !fs.existsSync(geminiAgentsDir)) {
-      const relativePath = path.relative(geminiDir, frameworkAgentsDir);
-      fs.symlinkSync(relativePath, geminiAgentsDir, "dir");
-      console.log(`🔗 Omni-Agent: Created symlink from .gemini/agents to ${targetBase}/agents`);
-    }
-  } catch (err) {
-    // Silently ignore if symlink fails (e.g. on non-compatible OS)
+  if (selectedAdapter === "gemini") {
+    console.log(`💎 Gemini: Adapter GEMINI.md and ${targetBase}/ folder are ready.`);
   }
 
-  if (selectedAdapter === "claude" || !selectedAdapter) {
+  if (selectedAdapter === "claude") {
     const mcpPath = path.join(targetDir, "packages/framework-mcp/src/index.ts");
     console.log("\n📝 Claude Code Setup:");
     console.log("To enable Agent Enderun tools in Claude Code, run this command:");
     console.log(`\x1b[36mclaude config add framework-mcp npx tsx ${mcpPath}\x1b[0m`);
   }
 
-  if (selectedAdapter === "cursor" || !selectedAdapter) {
-    console.log("✨ Cursor: Adapter CLAUDE.md and ENDERUN.md are ready to guide your AI.");
+  if (selectedAdapter === "cursor") {
+    const cursorRulesPath = path.join(targetDir, ".cursorrules");
+    const cursorMdPath = path.join(targetDir, "CURSOR.md");
+    if (fs.existsSync(cursorMdPath) && !fs.existsSync(cursorRulesPath)) {
+      fs.copyFileSync(cursorMdPath, cursorRulesPath);
+      console.log("🔗 Cursor: Synchronized CURSOR.md to .cursorrules");
+    }
   }
 
   const pkgMgr = getPackageManager();
-  console.log(`\nℹ️ Detected package manager: ${pkgMgr}`);
   const installCmd = pkgMgr === "npm" ? "npm install" : `${pkgMgr} install`;
   const buildCmd = pkgMgr === "npm" ? "npm run enderun:build" : `${pkgMgr} run enderun:build`;
 
-  console.log("\n✨ Framework scaffolded! (v" + FRAMEWORK_VERSION + ")");
+  console.log(`\n✨ Framework scaffolded! (v${FRAMEWORK_VERSION})`);
   
   try {
     const { execSync } = await import("child_process");
-    
     console.log(`\n📦 Step 1/3: Running '${installCmd}'...`);
     execSync(installCmd, { stdio: "inherit" });
-    
     console.log(`\n🏗️  Step 2/3: Running '${buildCmd}'...`);
     execSync(buildCmd, { stdio: "inherit" });
-    
     console.log(`\n🔍 Step 3/3: Running 'agent-enderun check'...`);
-    // Run the health check logic directly
-    await checkHealth();
-    
-    console.log("\n🚀 Agent Enderun is fully installed, built and verified!");
+    checkCommand();
+    console.log("\n🚀 Agent Enderun is fully installed and verified!");
   } catch (error) {
-    console.error("\n❌ Automatic installation failed. Please run manually:");
+    console.error("\n❌ Automatic installation failed. Run manually:");
     console.log(`👉 ${installCmd} && ${buildCmd}`);
   }
 }
@@ -593,8 +561,12 @@ function checkCommand() {
     { name: "Shared Types", path: "packages/shared-types/package.json" },
     { name: "MCP Server", path: "packages/framework-mcp/package.json" },
     { name: "Tech Stack", path: path.join(frameworkDir, "docs/tech-stack.md") },
-    { name: "Requirements", path: "docs/project-docs.md" },
+    { name: "Panda CSS Config", path: "panda.config.ts" },
+    { name: "Requirements", path: path.join(frameworkDir, "docs/project-docs.md") },
     { name: "API Registry", path: path.join(frameworkDir, "docs/api/README.md") },
+    { name: "Security Policy", path: path.join(frameworkDir, "docs/security.md") },
+    { name: "Privacy Policy", path: path.join(frameworkDir, "docs/privacy.md") },
+    { name: "Brain Dashboard", path: path.join(frameworkDir, "BRAIN_DASHBOARD.md") },
   ];
 
   for (const check of checks) {
@@ -637,6 +609,7 @@ function checkCommand() {
     console.log("\n🚀 All systems green! Agent Enderun is ready for orchestration.");
   } else {
     console.log(`\n⚠️  Found ${issues} issues. Please fix them before starting.`);
+    process.exit(1);
   }
 }
 
@@ -835,6 +808,156 @@ function verifyContractCommand() {
   }
 }
 
+function securityAuditCommand(targetPath) {
+  console.log(`🔍 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.log("✅ No security issues detected.");
+  } else {
+    issues.forEach(issue => console.log(`⚠️  ${issue}`));
+  }
+}
+
+function complianceCheckCommand(targetPath) {
+  console.log(`📜 Checking Constitution Compliance: ${targetPath}...`);
+  const violations = [];
+  const forbidden = ["@shadcn", "mui", "@chakra-ui", "tailwindcss"];
+  const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx", ".js", ".jsx", ".md"]);
+  files.forEach(f => {
+    const content = fs.readFileSync(f, "utf8");
+    forbidden.forEach(lib => {
+      if (content.includes(lib)) violations.push(`${path.relative(targetDir, f)}: Forbidden library '${lib}' found.`);
+    });
+    if (f.endsWith(".ts") && content.includes("interface") && content.match(/ID\s*:\s*string/)) {
+      violations.push(`${path.relative(targetDir, f)}: Potential Branded Types violation (ID typed as string).`);
+    }
+  });
+  if (violations.length === 0) {
+    console.log("✅ All systems compliant with ENDERUN.md.");
+  } else {
+    violations.forEach(v => console.log(`❌ ${v}`));
+  }
+}
+
+function gitCommitCommand(traceId) {
+  try {
+    const diff = cp.execSync("git diff --staged", { encoding: "utf8" });
+    if (!diff) {
+      console.log("ℹ️ No staged changes found. Use 'git add' first.");
+      return;
+    }
+    const files = cp.execSync("git diff --staged --name-only", { encoding: "utf8" }).split("\n").filter(Boolean);
+    let type = "feat", scope = "code";
+    if (files.some(f => f.includes(".md"))) type = "docs";
+    else if (files.some(f => f.includes("shared-types"))) type = "arch";
+    else if (files.some(f => f.includes("bin/cli.js"))) type = "fix";
+    
+    const summary = files.length === 1 ? `update ${path.basename(files[0])}` : `update ${files.length} files`;
+    console.log(`\n### SUGGESTED COMMIT MESSAGE ###\n\n[${traceId}] ${type}(${scope}): ${summary}\n`);
+  } catch (e) {
+    console.log("❌ Git command failed.");
+  }
+}
+
+function explorerGraphCommand(targetPath) {
+  console.log(`🗺️  Generating Dependency Graph for: ${targetPath}...`);
+  const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx"]);
+  const edges = [];
+  files.forEach(f => {
+    const content = fs.readFileSync(f, "utf8");
+    const name = path.basename(f, path.extname(f));
+    const imports = content.match(/from\s+['"]\.\.?\/[^'"]+['"]/g) || [];
+    imports.forEach(imp => {
+      const target = path.basename(imp.split(/['"]/)[1]);
+      edges.push(`${name} --> ${target}`);
+    });
+  });
+  if (edges.length === 0) {
+    console.log("ℹ️ No internal dependencies found.");
+  } else {
+    console.log("\n```mermaid\ngraph TD\n" + Array.from(new Set(edges)).join("\n") + "\n```\n");
+  }
+}
+
+function explorerAuditCommand(targetPath) {
+  console.log(`🧠 Codebase Intelligence Scan: ${targetPath}...`);
+  const files = collectFiles(path.join(targetDir, targetPath), [".ts", ".tsx"]);
+  const complexity = [];
+  files.forEach(f => {
+    const content = fs.readFileSync(f, "utf8");
+    const lines = content.split("\n").length;
+    if (lines > 300) complexity.push(`${path.relative(targetDir, f)} (${lines} lines)`);
+  });
+  if (complexity.length > 0) {
+    console.log("\n⚠️ Complexity Spikes:");
+    complexity.forEach(c => console.log(`- ${c}`));
+  } else {
+    console.log("✅ Codebase structure looks clean.");
+  }
+}
+
+function collectFiles(dir, extensions) {
+  let results = [];
+  if (!fs.existsSync(dir)) return results;
+  const list = fs.readdirSync(dir);
+  list.forEach(file => {
+    file = path.join(dir, file);
+    const stat = fs.statSync(file);
+    if (stat && stat.isDirectory()) {
+      if (!file.includes("node_modules") && !file.includes(".git")) {
+        results = results.concat(collectFiles(file, extensions));
+      }
+    } else {
+      if (extensions.includes(path.extname(file))) {
+        results.push(file);
+      }
+    }
+  });
+  return results;
+}
+
+function runScriptCommand(script, projectPath) {
+  const fullPath = path.join(targetDir, projectPath);
+  if (!fs.existsSync(fullPath)) {
+    console.log(`❌ Project path not found: ${projectPath}`);
+    return;
+  }
+  console.log(`🚀 Running 'npm run ${script}' in ${projectPath}...`);
+  try {
+    cp.spawnSync("npm", ["run", script], { cwd: fullPath, stdio: "inherit", shell: true });
+  } catch (e) {
+    console.log(`❌ Failed to run script: ${e.message}`);
+  }
+}
+
+function gitSyncCommand() {
+  console.log("🔄 Syncing with remote repository...");
+  try {
+    cp.execSync("git pull origin main --rebase", { stdio: "inherit" });
+    console.log("✅ Successfully synced and rebased.");
+  } catch (e) {
+    console.log("❌ Sync failed. Please resolve conflicts manually.");
+  }
+}
+
 function logAgentActionCommand(data) {
   const frameworkDir = getFrameworkDir();
   const logsDir = path.join(targetDir, frameworkDir, "logs");
@@ -921,6 +1044,11 @@ function updateProjectMemoryCommand(section, content) {
 async function main() {
   const [command, ...args] = process.argv.slice(2);
 
+  // Skip header for version and mcp commands to keep output clean
+  if (command !== "version" && command !== "-v" && command !== "--version" && command !== "mcp") {
+    console.log("🤖 Agent Enderun CLI — Initializing...");
+  }
+
   switch (command) {
     case "init":
       await initCommand(args[0]);
@@ -938,6 +1066,19 @@ async function main() {
     case "verify-contract":
       verifyContractCommand();
       break;
+    case "mcp": {
+      const mcpServerPath = path.join(sourceDir, "packages/framework-mcp/dist/index.js");
+      if (fs.existsSync(mcpServerPath)) {
+        const { spawn } = await import("child_process");
+        // Use node to execute the built MCP server
+        const child = spawn("node", [mcpServerPath], { stdio: "inherit" });
+        child.on("exit", (code) => process.exit(code || 0));
+      } else {
+        console.error("❌ MCP Server not built. Run 'npm run enderun:build' first.");
+        process.exit(1);
+      }
+      break;
+    }
     case "log_agent_action": {
       // Handle both structured JSON and positional args
       let data = {};
@@ -978,9 +1119,75 @@ async function main() {
       updateProjectMemoryCommand(section, content);
       break;
     }
+    case "update_knowledge_base": {
+      const topic = args[0];
+      const content = args.slice(1).join(" ");
+      if (!topic || !content) {
+        console.error("❌ Usage: agent-enderun update_knowledge_base <topic> <content>");
+        process.exit(1);
+      }
+      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.log(`✅ Knowledge base updated: ${topic}`);
+      break;
+    }
+    case "search_knowledge_base": {
+      const query = args[0];
+      if (!query) {
+        console.error("❌ Usage: agent-enderun search_knowledge_base <query>");
+        process.exit(1);
+      }
+      const frameworkDir = getFrameworkDir();
+      const kbDir = path.join(targetDir, frameworkDir, "knowledge");
+      if (!fs.existsSync(kbDir)) {
+        console.log("ℹ️ Knowledge base is empty.");
+        break;
+      }
+      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.log(`\n### ${file.replace(".md", "")}\n${content.slice(0, 300)}...`);
+          found = true;
+        }
+      }
+      if (!found) console.log("ℹ️ No matching entries found.");
+      break;
+    }
     case "check":
       checkCommand();
       break;
+    case "check:security":
+      securityAuditCommand(args[0] || ".");
+      break;
+    case "check:compliance":
+      complianceCheckCommand(args[0] || ".");
+      break;
+    case "git:commit":
+      gitCommitCommand(args[0] || "TRACE-ID-MISSING");
+      break;
+    case "explorer:graph":
+      explorerGraphCommand(args[0] || ".");
+      break;
+    case "explorer:audit":
+      explorerAuditCommand(args[0] || ".");
+      break;
+    case "frontend:dev":
+      runScriptCommand("dev", "apps/web");
+      break;
+    case "frontend:build":
+      runScriptCommand("build", "apps/web");
+      break;
+    case "mobile:dev":
+      runScriptCommand("start", "apps/mobile");
+      break;
+    case "git:sync":
+      gitSyncCommand();
+      break;
     case "version":
     case "-v":
     case "--version":
@@ -991,12 +1198,18 @@ async function main() {
 🤖 Agent Enderun CLI (v${FRAMEWORK_VERSION})
 
 Available Commands:
-  init [adapter]    Initialize the framework (gemini, claude, cursor, codex)
-  check             Verify framework health and MCP server status
-  status            Show current phase and task status
-  trace:new <desc>  Generate a new Trace ID and add the task to memory
-  verify-contract   Check if shared types match the stored hash
-  version           Show version information
+  init [adapter]      Initialize the framework (gemini, claude, cursor, codex)
+  check               Full health check
+  check:security      Run security audit scan
+  check:compliance    Run constitution compliance check
+  status              Show current phase and task status
+  trace:new <desc>    Generate a new Trace ID
+  verify-contract     Check shared types integrity
+  explorer:graph      Generate dependency graph
+  explorer:audit      Codebase intelligence scan
+  git:commit <id>     Suggest semantic commit message
+  mcp                 Start the MCP server
+  version             Show version information
 
 Example:
   agent-enderun trace:new "Auth module design" backend P1

package/package.json

@@ -1,23 +1,63 @@
 {
   "name": "agent-enderun",
-  "version": "0.1.10",
+  "version": "0.2.1",
+  "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
+  "author": "Yusuf BEKAR",
+  "license": "MIT",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ysf-bkr/Agent-Enderun.git"
+  },
+  "homepage": "https://github.com/ysf-bkr/Agent-Enderun#readme",
+  "bugs": {
+    "url": "https://github.com/ysf-bkr/Agent-Enderun/issues"
+  },
+  "keywords": [
+    "ai",
+    "governance",
+    "orchestration",
+    "agents",
+    "mcp",
+    "typescript",
+    "framework"
+  ],
   "workspaces": [
     "packages/*"
   ],
   "bin": {
     "agent-enderun": "bin/cli.js"
   },
+  "files": [
+    "bin",
+    "packages/shared-types/dist",
+    "packages/shared-types/src",
+    "packages/shared-types/package.json",
+    "packages/shared-types/README.md",
+    "packages/framework-mcp/dist",
+    "packages/framework-mcp/src",
+    "packages/framework-mcp/package.json",
+    "packages/framework-mcp/README.md",
+    ".enderun",
+    "ENDERUN.md",
+    "README.md",
+    "LICENSE",
+    "mcp.json",
+    ".env.example"
+  ],
   "scripts": {
     "enderun:build": "npm run build --prefix packages/shared-types && npm run build --prefix packages/framework-mcp",
     "enderun:status": "agent-enderun status",
     "enderun:trace": "agent-enderun trace:new",
     "enderun:verify": "agent-enderun verify-contract"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {},
   "devDependencies": {},
   "enderun": {
-    "version": "0.1.10",
+    "version": "0.2.1",
     "initializedAt": "2026-05-09T13:24:27.472Z"
   }
 }