agent-enderun 1.1.9 → 1.1.10

package/src/cli/utils/memory.ts

@@ -1,11 +1,13 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { sleep } from "./time.js";
-import { generateULID } from "./time.js";
-import { FRAMEWORK_DIR_CANDIDATES } from "../adapters.js";
-import { EnderunConfigSchema } from "./config-schema.js";
 import { logger } from "../../shared/logger.js";
+import { ensureDir } from "../../shared/fs.js";
+import { sleep } from "./time.js";
+import { StateSchema, AgentStatusSchema, TaskSchema } from "./schemas.js";
+
+export { generateULID } from "./time.js";
+export { FRAMEWORK_DIR_CANDIDATES } from "../adapters/index.js";
 
 const CWD = process.cwd();
 const HOME = os.homedir();
@@ -23,16 +25,6 @@ function findFrameworkDir(basePath: string): string | null {
     } catch (err) {
         logger.debug("Failed to read package.json in findFrameworkDir", err);
     }
-
-    for (const dir of FRAMEWORK_DIR_CANDIDATES) {
-        const dirPath = path.join(basePath, dir);
-        if (fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory()) {
-            const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md")) ||
-                              fs.existsSync(path.join(dirPath, "memory/PROJECT_MEMORY.md")) ||
-                              fs.existsSync(path.join(dirPath, "config.json"));
-            if (hasMemory) return dirPath;
-        }
-    }
     return null;
 }
 
@@ -44,179 +36,149 @@ export function getLocalFrameworkDir(): string {
 export function getConfigDir(): string {
     const localDir = findFrameworkDir(CWD);
     if (localDir) return localDir;
-    const globalDir = findFrameworkDir(HOME);
-    return globalDir || path.join(HOME, ".gemini");
+    return path.join(HOME, ".gemini");
 }
 
 export function getFrameworkDir(): string {
+    if (process.env.ENDERUN_TEST_DIR) return process.env.ENDERUN_TEST_DIR;
     return getConfigDir();
 }
 
-export function getMemoryPath() {
-    const frameworkDir = getLocalFrameworkDir();
-    const subPath = path.join(frameworkDir, "memory/PROJECT_MEMORY.md");
-    if (fs.existsSync(subPath)) return subPath;
-    return path.join(frameworkDir, "PROJECT_MEMORY.md");
+export function getDocumentStorePath() {
+    const frameworkDir = getFrameworkDir();
+    const store = path.join(frameworkDir, "memory");
+    console.warn(`[DEBUG] getDocumentStorePath returning ${store}`);
+    return store;
 }
 
-export function getConfiguredPaths(): { backend: string; frontend: string; docs: string; tests: string } {
-    const defaultPaths = { backend: "apps/backend", frontend: "apps/web", docs: "docs", tests: "tests" };
-    try {
-        const frameworkDir = getConfigDir();
-        const configPath = path.join(frameworkDir, "config.json");
-        if (fs.existsSync(configPath)) {
-            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            const result = EnderunConfigSchema.safeParse(rawConfig);
-            if (result.success) {
-                return result.data.paths;
-            } else {
-                console.error(`\n❌ Configuration Error in ${configPath}:`);
-                result.error.issues.forEach(err => console.error(`   - ${err.path.join(".")}: ${err.message}`));
-            }
-        }
-    } catch (err) {
-        console.error("\n❌ Critical Error: Could not read or parse configuration file.");
-        logger.debug("Critical config read failure", err);
+export function initDocumentStore(frameworkDir?: string) {
+    const storePath = frameworkDir ? path.join(frameworkDir, "memory") : getDocumentStorePath();
+    ensureDir(storePath);
+    ensureDir(path.join(storePath, "tasks"));
+    ensureDir(path.join(storePath, "history"));
+    
+    const stateFile = path.join(storePath, "state.json");
+    if (!fs.existsSync(stateFile)) {
+        fs.writeFileSync(stateFile, JSON.stringify({ phase: "PHASE_0", traceId: "T-000", managerState: "ACTIVE" }, null, 2));
+    }
+    const statusFile = path.join(storePath, "status.json");
+    if (!fs.existsSync(statusFile)) {
+        fs.writeFileSync(statusFile, JSON.stringify({}, null, 2));
     }
-    return defaultPaths;
 }
 
-export function acquireMemoryLock(lockPath: string, maxRetries = 5): boolean {
-    for (let attempt = 0; attempt < maxRetries; attempt += 1) {
-        try {
-            const fd = fs.openSync(lockPath, "wx");
-            fs.closeSync(fd);
-            return true;
-        } catch (error: unknown) {
-            const err = error as NodeJS.ErrnoException;
-            if (err?.code !== "EEXIST") throw error;
+export function readState() {
+    const statePath = path.join(getDocumentStorePath(), "state.json");
+    if (!fs.existsSync(statePath)) return null;
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}
 
-            try {
-                if (fs.existsSync(lockPath)) {
-                    const stat = fs.statSync(lockPath);
-                    const ageMs = Date.now() - stat.mtimeMs;
-                    if (ageMs > 10000) { // 10 seconds timeout for memory writes
-                        console.warn(`\n⚠️  Stale memory lock detected (${Math.round(ageMs / 1000)}s old). Breaking lock: ${lockPath}`);
-                        fs.unlinkSync(lockPath);
-                        // Retry immediately
-                        const fd = fs.openSync(lockPath, "wx");
-                        fs.closeSync(fd);
-                        return true;
-                    }
-                }
-            } catch (err) {
-                logger.debug("Lock check or breaking failed", err);
-            }
+export function readStatus() {
+    const statusPath = path.join(getDocumentStorePath(), "status.json");
+    if (!fs.existsSync(statusPath)) return {};
+    return JSON.parse(fs.readFileSync(statusPath, "utf8"));
+}
 
-            if (attempt < maxRetries - 1) sleep(1000);
-        }
-    }
-    return false;
+export function listTasks() {
+    const tasksPath = path.join(getDocumentStorePath(), "tasks");
+    if (!fs.existsSync(tasksPath)) return [];
+    
+    return fs.readdirSync(tasksPath)
+        .filter(f => f.endsWith(".json"))
+        .map(f => JSON.parse(fs.readFileSync(path.join(tasksPath, f), "utf8")));
 }
 
-export function releaseMemoryLock(lockPath: string): void {
-    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+export function getMemoryPath(): string {
+    return path.join(getDocumentStorePath(), "state.json");
 }
 
-export function initializeMemory(memoryPath: string, targetBase: string, dryRun = false): void {
-    if (fs.existsSync(memoryPath)) return;
-    const traceId = generateULID();
-    const date = new Date().toISOString().split("T")[0];
-    const template = `## CURRENT STATUS\n\n- Phase: PHASE_0 (Genesis)\n- Trace ID: ${traceId}\n\n## HISTORY\n### ${date} — Initialization\n- Action: Initialized Enderun Core.\n`;
-    if (dryRun) return;
-    const parentDir = path.dirname(memoryPath);
-    if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
-    fs.writeFileSync(memoryPath, template);
-    console.warn("✅ PROJECT_MEMORY.md initialized.");
-
-    const decisionsPath = path.join(parentDir, "DECISIONS.md");
-    if (!fs.existsSync(decisionsPath)) {
-        const decisionsTemplate = "# 🏛️ Architectural Decisions Log (ADR)\n\nThis file contains the fixed architectural choices and constraints for this project.\n\n## Decided Constraints\n- **Framework Integration:** Agent Enderun is the primary governance and orchestration layer.\n- **Language & Runtime:** TypeScript on Node.js.\n- **Package Manager:** npm.\n- **Monorepo Structure:** Monorepo using npm workspaces.\n- **Styling:** Panda CSS.\n";
-        fs.writeFileSync(decisionsPath, decisionsTemplate);
-        console.warn("✅ DECISIONS.md initialized.");
+export function readActiveTraceId(memoryContent: string): string | null {
+    try {
+        const state = JSON.parse(memoryContent);
+        return state.traceId || null;
+    } catch {
+        return null;
     }
 }
 
 export function updateProjectMemory(section: string, content: string) {
-    const memoryPath = getMemoryPath();
+    if (section === "HISTORY") {
+        updateDocumentStore("history", { content }, new Date().toISOString().replace(/[:.]/g, "-"));
+    } else {
+        const state = readState() || {};
+        state[section] = content;
+        updateDocumentStore("state", state);
+    }
+}
+
+export function initializeMemory(memoryPathOrBase: string, targetBaseOrDryRun?: string | boolean, dryRun = false): void {
+    const targetBase = typeof targetBaseOrDryRun === 'string' ? targetBaseOrDryRun : memoryPathOrBase;
+    initDocumentStore(targetBase);
+    logger.info("✅ Document store initialized.");
+}
 
-    if (!fs.existsSync(memoryPath)) {
-        console.error("❌ Error: PROJECT_MEMORY.md not found.");
-        return;
+export function getConfiguredPaths(): { backend: string; frontend: string; docs: string; tests: string } {
+    const defaultPaths = { backend: "apps/backend", frontend: "apps/web", docs: "docs", tests: "tests" };
+    try {
+        const frameworkDir = getConfigDir();
+        const configPath = path.join(frameworkDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return rawConfig.paths || defaultPaths;
+        }
+    } catch (err) {
+        logger.debug("Critical config read failure", err);
     }
+    return defaultPaths;
+}
 
-    const lockPath = `${memoryPath}.lock`;
-    if (!acquireMemoryLock(lockPath)) {
-        console.error("❌ Error: Memory lock timeout.");
-        return;
+export function updateDocumentStore(type: "state" | "task" | "history" | "status", data: unknown, id?: string, frameworkDir?: string) {
+    const storePath = frameworkDir ? path.join(frameworkDir, "memory") : getDocumentStorePath();
+    ensureDir(storePath);
+
+    switch (type) {
+        case "state":
+            StateSchema.parse(data);
+            fs.writeFileSync(path.join(storePath, "state.json"), JSON.stringify(data, null, 2));
+            break;
+        case "status":
+            AgentStatusSchema.parse(data);
+            fs.writeFileSync(path.join(storePath, "status.json"), JSON.stringify(data, null, 2));
+            break;
+        case "task":
+            TaskSchema.parse(data);
+            ensureDir(path.join(storePath, "tasks"));
+            fs.writeFileSync(path.join(storePath, "tasks", `${id}.json`), JSON.stringify(data, null, 2));
+            break;
+        case "history":
+            ensureDir(path.join(storePath, "history"));
+            fs.writeFileSync(path.join(storePath, "history", `${id}.json`), JSON.stringify(data, null, 2));
+            break;
     }
+}
 
+
+export function acquireMemoryLock(lockPath: string): boolean {
     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;
+        fs.writeFileSync(lockPath, String(Date.now()), { flag: 'wx' });
+        return true;
+    } catch (err: any) {
+        if (err.code === 'EEXIST') {
+            try {
+                const stat = fs.statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > 10000) {
+                    fs.unlinkSync(lockPath);
+                    fs.writeFileSync(lockPath, String(Date.now()), { flag: 'wx' });
+                    return true;
                 }
+            } catch {
+                // Ignore
             }
-
-            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);
+        return false;
     }
 }
 
-export function readActiveTraceId(memoryContent: string): string | null {
-    const match = memoryContent.match(/Trace ID:\s*([A-Z0-9]+)/i) ||
-                  memoryContent.match(/Trace ID\s*\|.*\|\s*\n\|.*\|.*\|.*\|\s*([A-Z0-9]+)\s*\|/i) ||
-                  memoryContent.match(/Active Trace ID[:\s|]+([A-Z0-9]+)/i);
-    return match ? match[1] : null;
+export function releaseMemoryLock(lockPath: string): void {
+    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
 }
-
-

package/src/cli/utils/pkg.ts

@@ -29,7 +29,7 @@ export function getPackageManager() {
  * Walks up from import.meta.url until it finds package.json with name === "agent-enderun".
  * This ensures getValidatorPath() and getPackageVersion() work correctly both in source tree
  * AND when the package is consumed from node_modules after `npm install agent-enderun` (global or local).
- * Critical for AL validation (validate-agent-army) and cross-adapter inits to work "kuraları npm'den".
+ * Critical for AL validation (validate-agent-army) and cross-adapter inits to work from npm.
  */
 function findAgentEnderunPackageRoot(): string {
     let current = path.dirname(new URL(import.meta.url).pathname);

package/src/cli/utils/schemas.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+export const StateSchema = z.object({
+    phase: z.string(),
+    traceId: z.string(),
+    managerState: z.enum(["ACTIVE", "IDLE", "PAUSED"]),
+});
+
+export const AgentStatusSchema = z.record(z.object({
+    state: z.enum(["READY", "EXECUTING", "BLOCKED", "TIMEOUT", "WAITING", "IDLE"]),
+    task: z.string(),
+    lastUpdated: z.string().optional(),
+}));
+
+export const TaskSchema = z.object({
+    traceId: z.string(),
+    description: z.string(),
+    agent: z.string(),
+    priority: z.enum(["P1", "P2", "P3", "HIGH", "NORMAL", "LOW"]),
+    status: z.enum(["PENDING", "IN_PROGRESS", "APPROVED", "COMPLETED"]),
+    createdAt: z.string(),
+});

package/src/cli/utils/string.ts

@@ -15,13 +15,20 @@ export function insertTaskRow(memoryContent: string, row: string): string | null
     );
 }
 
-export function sanitizeTableCell(value: unknown): string {
-    return String(value)
-        .replace(/\|/g, "\\|")
-        .replace(/\r?\n/g, " ")
+export function sanitizeInput(input: string): string {
+    return String(input)
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/[\r\n]+/g, " ")
+        .replace(/<script\b[^>]*>([\s\S]*?)<\/script>/gim, "") 
+        .replace(/--/g, "-") 
         .trim();
 }
 
+export function sanitizeTableCell(value: unknown): string {
+    return sanitizeInput(String(value)).replace(/\|/g, "\\|");
+}
+
 export function normalizeAgentName(agent?: unknown): string {
     return String(agent || "manager").replace(/^@+/, "").trim() || "manager";
 }

package/src/cli/utils/ui.ts

@@ -19,15 +19,18 @@ export const UI = {
      */
     agentBox: (agentName: string, action: string, details?: string) => {
         const width = process.stdout.columns || 80;
-        const line = "─".repeat(width - 2);
+        const line = "─".repeat(Math.max(0, width - 2));
         
         console.warn(chalk.gray(`╭${line}╮`));
-        console.warn(`${chalk.gray("│")} ${chalk.bold.yellow("≡")} ${chalk.white(`Running Agent: ${chalk.bold.green(agentName)}...`)} ${chalk.gray("(ctrl+o to expand)".padStart(width - agentName.length - 27))} ${chalk.gray("│")}`);
+        const padding = Math.max(0, width - agentName.length - 27);
+        console.warn(`${chalk.gray("│")} ${chalk.bold.yellow("≡")} ${chalk.white(`Running Agent: ${chalk.bold.green(agentName)}...`)} ${chalk.gray("(ctrl+o to expand)".padStart(padding))} ${chalk.gray("│")}`);
         if (action) {
-            console.warn(`${chalk.gray("│")} ${chalk.blue("!")} ${chalk.cyan(action)} ${" ".repeat(width - action.length - 6)} ${chalk.gray("│")}`);
+            const paddingAction = Math.max(0, width - action.length - 6);
+            console.warn(`${chalk.gray("│")} ${chalk.blue("!")} ${chalk.cyan(action)} ${" ".repeat(paddingAction)} ${chalk.gray("│")}`);
         }
         if (details) {
-            console.warn(`${chalk.gray("│")}   ${chalk.gray(details.slice(0, width - 10))} ${" ".repeat(width - details.length - 7)} ${chalk.gray("│")}`);
+            const paddingDetails = Math.max(0, width - details.length - 7);
+            console.warn(`${chalk.gray("│")}   ${chalk.gray(details.slice(0, width - 10))} ${" ".repeat(paddingDetails)} ${chalk.gray("│")}`);
         }
         console.warn(chalk.gray(`╰${line}╯`));
     },

package/src/contracts/index.ts

@@ -0,0 +1 @@
+export * from "./tasks.js";

package/src/contracts/tasks.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+
+/**
+ * Standard request contract sent to an agent.
+ */
+export const TaskRequestSchema = z.object({
+    traceId: z.string(),
+    task: z.string(),
+    priority: z.enum(["P1", "P2", "P3", "HIGH", "NORMAL", "LOW"]),
+    agent: z.string(),
+    context: z.record(z.unknown()).optional(),
+});
+
+export type TaskRequest = z.infer<typeof TaskRequestSchema>;
+
+/**
+ * Standard response contract sent back by an agent.
+ */
+export const TaskResponseSchema = z.object({
+    traceId: z.string(),
+    status: z.enum(["SUCCESS", "FAILED", "RETRY", "WAITING_FOR_APPROVAL"]),
+    message: z.string().optional(),
+    errorCode: z.string().optional(),
+});
+
+export type TaskResponse = z.infer<typeof TaskResponseSchema>;

package/src/modules/adapters/definitions.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import type { AdapterConfig, AdapterId } from "../../cli/adapters/types.js";
+import type { AdapterConfig, AdapterId } from "./types.js";
 import { addMcpServerToClaude, findClaudeConfigPath } from "../../cli/utils/claude.js";
 import { writeJsonFile } from "../../shared/fs.js";
 import { registerGlobalAntigravityPlugins } from "./shared.js";

package/src/modules/adapters/shared.ts

@@ -2,7 +2,7 @@ import path from "path";
 import fs from "fs";
 import os from "os";
 import { writeJsonFile } from "../../shared/fs.js";
-import { ALL_AGENTS, buildAgentJson } from "../agents/definitions.js";
+import { ALL_AGENTS, toAntigravityJson } from "../agents/definitions.js";
 import { CORE_SKILLS } from "../skills/definitions.js";
 
 export function registerGlobalAntigravityPlugins(mcpBlock: unknown): void {
@@ -37,7 +37,7 @@ export function registerGlobalAntigravityPlugins(mcpBlock: unknown): void {
             const agentsBaseDir = path.join(globalPluginDir, "agents");
             fs.mkdirSync(agentsBaseDir, { recursive: true });
             for (const ag of ALL_AGENTS) {
-                const agentJson = buildAgentJson(ag);
+                const agentJson = toAntigravityJson(ag);
 
                 // 1. Nested format (agents/{agent_name}/agent.json)
                 const nestedAgentDir = path.join(agentsBaseDir, ag.name);
@@ -65,7 +65,13 @@ export function registerGlobalAntigravityPlugins(mcpBlock: unknown): void {
 You are the **${ag.displayName}** of the Agent Enderun Army.
 
 ## 🤖 Specialist Directive (Role: @${ag.name})
-${ag.instructions}
+${ag.instructions.identity}
+
+### 🎯 Mission
+${ag.instructions.mission}
+
+### 📜 Discipline Rules
+${ag.instructions.rules.map(r => `- ${r}`).join("\n")}
 
 ## 🛡️ Core Mandates
 - **Surgical Precision:** Enforce replace_text / replace_file_content for all code modifications.

package/src/modules/adapters/types.ts

@@ -11,6 +11,6 @@ export interface AdapterConfig {
   role: AdapterRole;
   templateDir: ".enderun";
   nestedDirs?: string[];
-  rulesDir?: string; // Directory to write individual rules, relative to projectRoot
-  rulesExt?: string; // Extensions for rules files (.md or .mdc)
+  agentsDir?: string; // Directory to write individual agents/rules, relative to projectRoot
+  agentsExt?: string; // Extensions for agent files (.md or .mdc)
 }