agent-enderun 1.1.1 → 1.1.3

package/framework-mcp/src/tools/file_system/read_file.ts

@@ -4,6 +4,30 @@ import { ToolArgs, ToolResult } from "../types.js";
 
 export function handleReadFile(projectRoot: string, args: ToolArgs): ToolResult {
     const filePath = safePath(projectRoot, args.path as string);
+    const startLine = args.startLine !== undefined ? Number(args.startLine) : undefined;
+    const endLine = args.endLine !== undefined ? Number(args.endLine) : undefined;
+
     const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+
+    if (startLine !== undefined || endLine !== undefined) {
+        const start = startLine !== undefined ? Math.max(1, startLine) - 1 : 0;
+        const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
+        const sliced = lines.slice(start, end).join("\n");
+        return { content: [{ type: "text", text: sliced }] };
+    }
+
+    // Default protection limit: 1000 lines
+    const DEFAULT_MAX_LINES = 1000;
+    if (lines.length > DEFAULT_MAX_LINES) {
+        const sliced = lines.slice(0, DEFAULT_MAX_LINES).join("\n");
+        return {
+            content: [{
+                type: "text",
+                text: `${sliced}\n\n... [TRUNCATED - File is too long (${lines.length} lines). Only the first ${DEFAULT_MAX_LINES} lines are shown. Use startLine and endLine parameters to read other parts of the file.]`
+            }]
+        };
+    }
+
     return { content: [{ type: "text", text: content }] };
 }

package/framework-mcp/src/tools/file_system/write_file.ts

@@ -1,11 +1,28 @@
 import fs from "fs";
 import path from "path";
-import { safePath } from "../../utils/security.js";
+import { safePath, resolveFrameworkDir } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
 import { ToolArgs, ToolResult } from "../types.js";
 
 export function handleWriteFile(projectRoot: string, args: ToolArgs): ToolResult {
     const filePath = safePath(projectRoot, args.path as string);
+    const content = args.content as string;
+    
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, args.content as string);
+    fs.writeFileSync(filePath, content);
+    
+    // AUTO-LOGGING & METRICS
+    const tokens = Metrics.estimateTokens(content);
+    Metrics.logUsage(projectRoot, "@mcp", `write_file: ${args.path}`, tokens);
+
+    try {
+        const frameworkDir = resolveFrameworkDir(projectRoot);
+        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
+        if (fs.existsSync(memoryPath)) {
+            const entry = `\n### ${new Date().toISOString().split("T")[0]} — Auto-Update\n- **Action:** wrote file \`${args.path}\` (${tokens} tokens estimated).\n`;
+            fs.appendFileSync(memoryPath, entry);
+        }
+    } catch { /* ignore memory logging errors */ }
+
     return { content: [{ type: "text", text: `✅ File written: ${args.path}` }] };
 }

package/framework-mcp/src/tools/index.ts

@@ -9,10 +9,12 @@ import { handleOrchestrateLoop } from "./framework/orchestrate.js";
 import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
 import { handleSendAgentMessage } from "./messaging/send_message.js";
 import { handleLogAgentAction } from "./messaging/log_action.js";
+import { handleAcquireLock, handleReleaseLock } from "./control_plane/locking.js";
+import { handleRegisterAgent } from "./control_plane/registry.js";
 import { ToolResult, ToolArgs } from "./types.js";
 
 // Define a type for the tool handlers
-export type ToolHandler = (projectRoot: string, args: ToolArgs) => ToolResult;
+export type ToolHandler = (projectRoot: string, args: ToolArgs) => ToolResult | Promise<ToolResult>;
 
 // Map of tool names to their handler functions
 export const toolHandlers: Record<string, ToolHandler> = {
@@ -26,6 +28,9 @@ export const toolHandlers: Record<string, ToolHandler> = {
     send_agent_message: handleSendAgentMessage,
     log_agent_action: handleLogAgentAction,
     update_contract_hash: handleUpdateContractHash,
+    acquire_lock: handleAcquireLock as ToolHandler,
+    release_lock: handleReleaseLock as ToolHandler,
+    register_agent: handleRegisterAgent as ToolHandler,
 };
 
 export { TOOLS };

package/framework-mcp/src/tools/messaging/send_message.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
 import { ToolArgs, ToolResult } from "../types.js";
 
-export function handleSendAgentMessage(projectRoot: string, args: ToolArgs): ToolResult {
+export async function handleSendAgentMessage(projectRoot: string, args: ToolArgs): Promise<ToolResult> {
     const { to, category, content, traceId } = args as Required<Pick<ToolArgs, "to" | "category" | "content" | "traceId">>;
     const from = (args.from as string) || "@mcp";
 
@@ -23,8 +23,7 @@ export function handleSendAgentMessage(projectRoot: string, args: ToolArgs): Too
         }
         retries--;
         if (retries > 0) {
-            const start = Date.now();
-            while (Date.now() - start < 500); // Simple busy wait for MCP environment
+            await new Promise((resolve) => setTimeout(resolve, 500));
         }
     }
 

package/framework-mcp/src/utils/metrics.ts

@@ -0,0 +1,53 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "./security.js";
+
+/**
+ * Token and Metric Tracker for Enderun Core.
+ * Estimates token usage and logs operational costs.
+ */
+
+interface MetricEntry {
+    timestamp: string;
+    agent: string;
+    action: string;
+    estimatedTokens: number;
+}
+
+export const Metrics = {
+    /**
+     * Estimates tokens based on character count (rough heuristic: 1 token ~= 4 chars).
+     */
+    estimateTokens: (text: string): number => {
+        return Math.ceil(text.length / 4);
+    },
+
+    /**
+     * Logs the token usage and action to the observability metrics file.
+     */
+    logUsage: (projectRoot: string, agent: string, action: string, tokens: number) => {
+        const frameworkDir = resolveFrameworkDir(projectRoot);
+        const metricsPath = path.join(projectRoot, frameworkDir, "observability/metrics.json");
+        try {
+            const metricsDir = path.dirname(metricsPath);
+            if (!fs.existsSync(metricsDir)) fs.mkdirSync(metricsDir, { recursive: true });
+
+            let currentMetrics: MetricEntry[] = [];
+            if (fs.existsSync(metricsPath)) {
+                currentMetrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
+            }
+
+            currentMetrics.push({
+                timestamp: new Date().toISOString(),
+                agent,
+                action,
+                estimatedTokens: tokens
+            });
+
+            // Keep only last 100 entries to save space
+            if (currentMetrics.length > 100) currentMetrics.shift();
+
+            fs.writeFileSync(metricsPath, JSON.stringify(currentMetrics, null, 2));
+        } catch { /* ignore: metrics should not block the main process */ }
+    }
+};

package/framework-mcp/src/utils/security.ts

@@ -37,15 +37,19 @@ export function resolveFrameworkDir(projectRoot: string): string {
         // ignore — fall through to filesystem scan
     }
 
-    // 2. Filesystem scan — .enderun takes precedence over adapter-specific dirs
+    // 2. Filesystem scan
     const candidates = [
         ".enderun",
+        ".cursor",
         ".claude",
+        ".github",
         ".grok",
+        ".windsurf",
+        ".antigravity",
         ".agent",
-        ".gemini/antigravity",
         ".gemini/antigravity-cli",
         ".gemini",
+        ".agents",
     ];
 
     for (const candidate of candidates) {
@@ -55,5 +59,6 @@ export function resolveFrameworkDir(projectRoot: string): string {
         }
     }
 
-    return ".enderun";
+    return ".gemini";
 }
+

package/framework-mcp/tests/tools/file_system/file_system_tools.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import { handleReplaceText } from "../../../src/tools/file_system/replace_text.js";
+import { handlePatchFile } from "../../../src/tools/file_system/patch_file.js";
+import { handleReadFile } from "../../../src/tools/file_system/read_file.js";
+import { handleWriteFile } from "../../../src/tools/file_system/write_file.js";
+import { ToolArgs } from "../../../src/tools/types.js";
+
+const TEST_DIR = path.join(__dirname, "../_temp_test_files");
+const TEST_FILE = path.join(TEST_DIR, "test_file.txt");
+const MEMORY_DIR = path.join(TEST_DIR, ".gemini/memory");
+const MEMORY_FILE = path.join(MEMORY_DIR, "PROJECT_MEMORY.md");
+
+beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+describe("File System Tools", () => {
+    
+    describe("handleReplaceText", () => {
+        it("should replace a single occurrence of text", () => {
+            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                oldText: "world",
+                newText: "there",
+            };
+            const result = handleReplaceText(TEST_DIR, args);
+            expect(result.content[0].text).toContain("✅ Surgical edit successful");
+            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there");
+        });
+
+        it("should throw an error if text is not found", () => {
+            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                oldText: "missing",
+                newText: "found",
+            };
+            expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Text not found in file");
+        });
+
+        it("should throw an error for ambiguous replacement if allowMultiple is false", () => {
+            fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                oldText: "world",
+                newText: "there",
+                allowMultiple: false,
+            };
+            expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Ambiguous replacement");
+        });
+
+        it("should replace all occurrences of text if allowMultiple is true", () => {
+            fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                oldText: "world",
+                newText: "there",
+                allowMultiple: true,
+            };
+            const result = handleReplaceText(TEST_DIR, args);
+            expect(result.content[0].text).toContain("✅ Surgical edit successful");
+            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there there");
+        });
+    });
+
+    describe("handlePatchFile", () => {
+        it("should replace lines in specified range", () => {
+            fs.writeFileSync(TEST_FILE, "line1\nline2\nline3\nline4", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                startLine: 2,
+                endLine: 3,
+                newContent: "patched2\npatched3",
+            };
+            const result = handlePatchFile(TEST_DIR, args);
+            expect(result.content[0].text).toContain("✅ File patched successfully");
+            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("line1\npatched2\npatched3\nline4");
+        });
+
+        it("should throw an error for invalid start line", () => {
+            fs.writeFileSync(TEST_FILE, "line1\nline2", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                startLine: 5,
+                endLine: 2,
+                newContent: "error",
+            };
+            expect(() => handlePatchFile(TEST_DIR, args)).toThrowError("Invalid start line");
+        });
+
+        it("should throw an error for invalid end line", () => {
+            fs.writeFileSync(TEST_FILE, "line1\nline2", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                startLine: 1,
+                endLine: 5,
+                newContent: "error",
+            };
+            expect(() => handlePatchFile(TEST_DIR, args)).toThrowError("Invalid end line");
+        });
+    });
+
+    describe("handleReadFile", () => {
+        it("should read full file content", () => {
+            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
+            const args: ToolArgs = { path: TEST_FILE };
+            const result = handleReadFile(TEST_DIR, args);
+            expect(result.content[0].text).toBe("hello world");
+        });
+
+        it("should read sliced lines", () => {
+            fs.writeFileSync(TEST_FILE, "line1\nline2\nline3\nline4", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                startLine: 2,
+                endLine: 3
+            };
+            const result = handleReadFile(TEST_DIR, args);
+            expect(result.content[0].text).toBe("line2\nline3");
+        });
+
+        it("should truncate long files", () => {
+            const longContent = Array.from({ length: 1005 }, (_, i) => `line ${i + 1}`).join("\n");
+            fs.writeFileSync(TEST_FILE, longContent, "utf8");
+            const args: ToolArgs = { path: TEST_FILE };
+            const result = handleReadFile(TEST_DIR, args);
+            expect(result.content[0].text).toContain("TRUNCATED");
+            expect(result.content[0].text).toContain("line 1000");
+            expect(result.content[0].text).not.toContain("line 1001");
+        });
+    });
+
+    describe("handleWriteFile", () => {
+        it("should write new file and log usage", () => {
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                content: "hello world"
+            };
+            const result = handleWriteFile(TEST_DIR, args);
+            expect(result.content[0].text).toContain("✅ File written");
+            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello world");
+        });
+
+        it("should append update to PROJECT_MEMORY.md if it exists", () => {
+            fs.mkdirSync(MEMORY_DIR, { recursive: true });
+            fs.writeFileSync(MEMORY_FILE, "## CURRENT STATUS\n", "utf8");
+            const args: ToolArgs = {
+                path: TEST_FILE,
+                content: "hello world"
+            };
+            handleWriteFile(TEST_DIR, args);
+            const memoryContent = fs.readFileSync(MEMORY_FILE, "utf8");
+            expect(memoryContent).toContain("Auto-Update");
+            expect(memoryContent).toContain("wrote file");
+        });
+    });
+});

package/framework-mcp/tsconfig.json

@@ -6,7 +6,8 @@
     "outDir": "./dist",
     "strict": true,
     "skipLibCheck": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "types": ["node"]
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -24,7 +24,6 @@
     "framework"
   ],
   "workspaces": [
-    "apps/*",
     "framework-mcp"
   ],
   "bin": {
@@ -39,7 +38,6 @@
     "ENDERUN.md",
     "README.md",
     "LICENSE",
-    "mcp.json",
     "tsconfig.json",
     "eslint.config.js",
     "panda.config.ts",
@@ -47,9 +45,12 @@
     "CLAUDE.md",
     "GROK.md",
     "agent.md",
-    "docs"
+    "docs",
+    ".cursor",
+    ".github"
   ],
   "scripts": {
+    "build": "tsc && npm run build --prefix framework-mcp",
     "enderun:build": "npm run build --prefix framework-mcp",
     "enderun:test": "vitest run",
     "enderun:test:watch": "vitest",
@@ -58,10 +59,13 @@
     "enderun:verify": "agent-enderun verify-contract",
     "enderun:update-contract": "agent-enderun update-contract",
     "enderun:check": "agent-enderun check",
+    "enderun:dashboard": "node bin/enderun-dashboard.js",
+    "test:init": "node dist/src/cli/index.js init",
+    "test:init:run": "node bin/test-init-run.js",
     "enderun:lint": "eslint .",
     "lint": "eslint .",
-    "prepublishOnly": "npm run enderun:build",
-    "clean": "rm -rf node_modules apps/*/node_modules framework-mcp/node_modules apps/*/dist framework-mcp/dist"
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist node_modules framework-mcp/node_modules framework-mcp/dist"
   },
   "publishConfig": {
     "access": "public"
@@ -71,10 +75,8 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@pandacss/dev": "^1.11.1",
     "@types/node": "^25.9.1",
-    "concurrently": "^9.2.1",
     "eslint": "^10.4.0",
     "globals": "^17.6.0",
-    "ts-morph": "^28.0.0",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.0",
@@ -82,9 +84,10 @@
     "zod": "^3.24.2"
   },
   "enderun": {
-    "version": "1.1.0",
-    "initializedAt": "2026-05-31T09:58:25.773Z",
-    "frameworkDir": ".enderun"
+    "version": "1.1.3",
+    "initializedAt": "2026-06-04T18:51:28.970Z"
   },
-  "dependencies": {}
-}
+  "dependencies": {
+    "chalk": "^5.6.2"
+  }
+}

package/src/cli/adapters/types.ts

@@ -0,0 +1,16 @@
+export const ADAPTER_IDS = ["gemini", "claude", "grok", "cursor", "codex", "antigravity-cli"] as const;
+export type AdapterId = (typeof ADAPTER_IDS)[number];
+
+export type AdapterRole = "commander" | "architect" | "researcher" | "implementer" | "general";
+
+export interface AdapterConfig {
+  id: AdapterId;
+  frameworkDir: string;
+  shimFile: string;
+  shimTemplate: string;
+  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)
+}