agent-enderun 0.7.2 → 0.8.0

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

@@ -0,0 +1,353 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { promises as fs } from "fs";
+import path from "path";
+
+// ─── Types ─────────────────────────────────────────────────────────────────────
+
+type PipelineStage = {
+  id: string;
+  name: string;
+  agent: string;
+  status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "SKIPPED";
+  dependsOn: string[];
+  startedAt?: string;
+  completedAt?: string;
+  output?: string;
+};
+
+type Pipeline = {
+  id: string;
+  traceId: string;
+  name: string;
+  description: string;
+  createdAt: string;
+  updatedAt: string;
+  status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "ROLLED_BACK";
+  currentStageId?: string;
+  stages: PipelineStage[];
+  rollbackStages?: PipelineStage[];
+};
+
+// ─── Tool Definitions ─────────────────────────────────────────────────────────
+
+export const pipelineTools: Tool[] = [
+  {
+    name: "create_execution_pipeline",
+    description:
+      "Creates a multi-stage execution pipeline for complex workflows (e.g., build → test → security audit → deploy). Each stage is assigned to a specific agent and has defined dependencies. The pipeline is persisted and can be advanced or rolled back.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        traceId: { type: "string", description: "Active Trace ID from @manager briefing" },
+        name: { type: "string", description: "Pipeline name (e.g. 'Production Deploy v1.2.0')" },
+        description: { type: "string", description: "What this pipeline accomplishes" },
+        stages: {
+          type: "array",
+          description: "Ordered pipeline stages",
+          items: {
+            type: "object",
+            required: ["id", "name", "agent"],
+            properties: {
+              id: { type: "string" },
+              name: { type: "string" },
+              agent: { type: "string" },
+              dependsOn: { type: "array", items: { type: "string" } },
+            },
+          },
+        },
+        rollbackStages: {
+          type: "array",
+          description: "Optional rollback stages executed in reverse order on pipeline failure",
+          items: {
+            type: "object",
+            required: ["id", "name", "agent"],
+            properties: {
+              id: { type: "string" },
+              name: { type: "string" },
+              agent: { type: "string" },
+              dependsOn: { type: "array", items: { type: "string" } },
+            },
+          },
+        },
+      },
+      required: ["traceId", "name", "stages"],
+    },
+  },
+  {
+    name: "advance_pipeline_stage",
+    description:
+      "Advances a pipeline to the next eligible stage. Marks the current stage as COMPLETED and activates all dependent stages that now have their dependencies satisfied. Returns the new pipeline state.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pipelineId: { type: "string", description: "Pipeline ID" },
+        completedStageId: { type: "string", description: "The stage that just completed successfully" },
+        stageOutput: { type: "string", description: "Optional output/result from the completed stage" },
+      },
+      required: ["pipelineId", "completedStageId"],
+    },
+  },
+  {
+    name: "rollback_pipeline",
+    description:
+      "Rolls back a pipeline to the last stable state by executing the defined rollback stages in reverse order. Updates the pipeline status to ROLLED_BACK.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pipelineId: { type: "string", description: "Pipeline ID to roll back" },
+        reason: { type: "string", description: "Reason for the rollback (mandatory for audit)" },
+      },
+      required: ["pipelineId", "reason"],
+    },
+  },
+  {
+    name: "get_pipeline_status",
+    description:
+      "Returns the full current status of a pipeline including all stage states, progress percentage, blocking stages, and estimated completion.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pipelineId: { type: "string", description: "Pipeline ID" },
+      },
+      required: ["pipelineId"],
+    },
+  },
+];
+
+// ─── Handlers ─────────────────────────────────────────────────────────────────
+
+export const pipelineHandlers: Record<
+  string,
+  (args: unknown, projectRoot: string) => Promise<{ content: Array<{ type: string; text: string }> }>
+> = {
+  async create_execution_pipeline(args, projectRoot) {
+    const { traceId, name, description, stages, rollbackStages } = args as {
+      traceId: string;
+      name: string;
+      description?: string;
+      stages: Omit<PipelineStage, "status" | "startedAt" | "completedAt" | "output">[];
+      rollbackStages?: Omit<PipelineStage, "status" | "startedAt" | "completedAt" | "output">[];
+    };
+
+    const pipelineId = `PIPE-${traceId}-${Date.now()}`;
+    const now = new Date().toISOString();
+
+    const pipeline: Pipeline = {
+      id: pipelineId,
+      traceId,
+      name,
+      description: description ?? "",
+      createdAt: now,
+      updatedAt: now,
+      status: "PENDING",
+      stages: stages.map((s) => ({
+        ...s,
+        dependsOn: s.dependsOn ?? [],
+        status: "PENDING" as const,
+      })),
+      rollbackStages: rollbackStages?.map((s) => ({
+        ...s,
+        dependsOn: s.dependsOn ?? [],
+        status: "PENDING" as const,
+      })),
+    };
+
+    // Activate stages with no dependencies
+    for (const stage of pipeline.stages) {
+      if (stage.dependsOn.length === 0) {
+        stage.status = "RUNNING";
+        stage.startedAt = now;
+      }
+    }
+    pipeline.status = "RUNNING";
+
+    // Persist pipeline
+    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+    await fs.mkdir(pipelineDir, { recursive: true });
+    await fs.writeFile(
+      path.join(pipelineDir, `${pipelineId}.json`),
+      JSON.stringify(pipeline, null, 2),
+      "utf-8"
+    );
+
+    return { content: [{ type: "text", text: JSON.stringify(pipeline, null, 2) }] };
+  },
+
+  async advance_pipeline_stage(args, projectRoot) {
+    const { pipelineId, completedStageId, stageOutput } = args as {
+      pipelineId: string;
+      completedStageId: string;
+      stageOutput?: string;
+    };
+
+    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+    const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
+
+    let pipeline: Pipeline;
+    try {
+      const content = await fs.readFile(pipelinePath, "utf-8");
+      pipeline = JSON.parse(content) as Pipeline;
+    } catch {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+        ],
+      };
+    }
+
+    const now = new Date().toISOString();
+
+    // Mark completed stage
+    const completedStage = pipeline.stages.find((s) => s.id === completedStageId);
+    if (!completedStage) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: "STAGE_NOT_FOUND", completedStageId }) },
+        ],
+      };
+    }
+    completedStage.status = "COMPLETED";
+    completedStage.completedAt = now;
+    if (stageOutput) completedStage.output = stageOutput;
+
+    // Activate newly unblocked stages
+    const completedIds = new Set(pipeline.stages.filter((s) => s.status === "COMPLETED").map((s) => s.id));
+    const newlyActivated: string[] = [];
+
+    for (const stage of pipeline.stages) {
+      if (stage.status === "PENDING" && stage.dependsOn.every((dep) => completedIds.has(dep))) {
+        stage.status = "RUNNING";
+        stage.startedAt = now;
+        newlyActivated.push(stage.id);
+      }
+    }
+
+    // Check if pipeline is complete
+    const allDone = pipeline.stages.every((s) => s.status === "COMPLETED");
+    if (allDone) {
+      pipeline.status = "COMPLETED";
+    }
+
+    pipeline.updatedAt = now;
+    await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ pipeline, newlyActivatedStages: newlyActivated }, null, 2),
+        },
+      ],
+    };
+  },
+
+  async rollback_pipeline(args, projectRoot) {
+    const { pipelineId, reason } = args as { pipelineId: string; reason: string };
+
+    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+    const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
+
+    let pipeline: Pipeline;
+    try {
+      const content = await fs.readFile(pipelinePath, "utf-8");
+      pipeline = JSON.parse(content) as Pipeline;
+    } catch {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+        ],
+      };
+    }
+
+    const now = new Date().toISOString();
+    pipeline.status = "ROLLED_BACK";
+    pipeline.updatedAt = now;
+
+    // Mark all non-completed stages as SKIPPED
+    for (const stage of pipeline.stages) {
+      if (stage.status === "RUNNING" || stage.status === "PENDING") {
+        stage.status = "SKIPPED";
+      }
+    }
+
+    // Activate rollback stages if defined
+    if (pipeline.rollbackStages) {
+      for (const stage of pipeline.rollbackStages) {
+        stage.status = "RUNNING";
+        stage.startedAt = now;
+      }
+    }
+
+    await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
+
+    // Write rollback event to devops log
+    const devopsLogPath = path.join(projectRoot, ".enderun", "logs", "devops.json");
+    let devopsLog: { rollbacks: unknown[] } = { rollbacks: [] };
+    try {
+      const existing = await fs.readFile(devopsLogPath, "utf-8");
+      devopsLog = JSON.parse(existing) as typeof devopsLog;
+      if (!devopsLog.rollbacks) devopsLog.rollbacks = [];
+    } catch {
+      // Start fresh
+    }
+    devopsLog.rollbacks.push({ pipelineId, reason, timestamp: now });
+    await fs.mkdir(path.dirname(devopsLogPath), { recursive: true });
+    await fs.writeFile(devopsLogPath, JSON.stringify(devopsLog, null, 2), "utf-8");
+
+    return { content: [{ type: "text", text: JSON.stringify({ pipeline, rollbackReason: reason }, null, 2) }] };
+  },
+
+  async get_pipeline_status(args, projectRoot) {
+    const { pipelineId } = args as { pipelineId: string };
+    const pipelinePath = path.join(
+      projectRoot,
+      ".enderun",
+      "queue",
+      "pipelines",
+      `${pipelineId}.json`
+    );
+
+    try {
+      const content = await fs.readFile(pipelinePath, "utf-8");
+      const pipeline = JSON.parse(content) as Pipeline;
+
+      const total = pipeline.stages.length;
+      const completed = pipeline.stages.filter((s) => s.status === "COMPLETED").length;
+      const running = pipeline.stages.filter((s) => s.status === "RUNNING").map((s) => s.id);
+      const blocked = pipeline.stages.filter(
+        (s) => s.status === "PENDING" && s.dependsOn.some((dep) => {
+          const depStage = pipeline.stages.find((st) => st.id === dep);
+          return depStage && depStage.status !== "COMPLETED";
+        })
+      ).map((s) => s.id);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                pipelineId,
+                name: pipeline.name,
+                status: pipeline.status,
+                progress: `${completed}/${total} stages (${Math.round((completed / total) * 100)}%)`,
+                currentlyRunning: running,
+                waitingOn: blocked,
+                createdAt: pipeline.createdAt,
+                updatedAt: pipeline.updatedAt,
+              },
+              null,
+              2
+            ),
+          },
+        ],
+      };
+    } catch {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+        ],
+      };
+    }
+  },
+};

package/framework-mcp/src/utils.ts

@@ -10,7 +10,7 @@ const getPackageVersion = (): string => {
         const pkgPath = path.join(__dirname, "../package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.7.1";
+            return pkg.version || "0.7.5";
         }
     } catch {
         // fallback
@@ -20,8 +20,29 @@ const getPackageVersion = (): string => {
 
 export const FRAMEWORK_VERSION = getPackageVersion();
 
-export function getFrameworkDir(_projectRoot: string): string {
-    return ".agents"; // Antigravity-only runtime folder
+/**
+ * Dynamically detects the framework directory for the current project.
+ * Checks in priority order: .enderun → .gemini → .cursor → fallback .gemini
+ * This resolves the adapter mismatch bug (KRITIK-1 in v0.7.5 analysis).
+ */
+export function getFrameworkDir(projectRoot: string): string {
+    const candidates = [".enderun", ".gemini", ".cursor"];
+    for (const dir of candidates) {
+        const dirPath = path.join(projectRoot, dir);
+        if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+            // Verify it looks like a framework dir (has PROJECT_MEMORY.md or agents/ dir)
+            const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md"));
+            const hasAgents = fs.existsSync(path.join(dirPath, "agents"));
+            if (hasMemory || hasAgents) {
+                return dir;
+            }
+        }
+    }
+    // Ultimate fallback — return first existing dir or .gemini
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(projectRoot, dir))) return dir;
+    }
+    return ".gemini";
 }
 
 export function resolveSafePath(projectRoot: string, targetPath: string): string {

package/framework-mcp/tsconfig.json

@@ -8,7 +8,8 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "allowJs": true
+    "allowJs": true,
+    "types": ["node"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/gemini.md

@@ -0,0 +1,19 @@
+# Agent Enderun — Gemini CLI Adapter
+
+This file is the entry point when using Agent Enderun with Gemini CLI.
+
+The framework installs into the `.gemini/` folder for Gemini users.
+
+### Primary Constitution
+All governance rules, agent checklists, and project memory live here:
+
+👉 **[.gemini/ENDERUN.md](.gemini/ENDERUN.md)**
+
+### 🤖 Agent Directive (Gemini CLI users)
+You are operating under the Agent Enderun governance framework.
+
+At the **start of every session**, before any work:
+1. Read `.gemini/PROJECT_MEMORY.md` to restore state, active Trace ID, and history.
+2. Read the relevant agent definition under `.gemini/agents/{agent}/agent.json` (especially `@manager`).
+
+All paths and references inside `.gemini/` use the Gemini adapter structure. No migration to other CLIs is required.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "framework-mcp/dist",
     "framework-mcp/src",
     "framework-mcp/package.json",
-    ".antigravitycli",
+    ".enderun",
     "ENDERUN.md",
     "README.md",
     "LICENSE",
@@ -43,7 +43,9 @@
     ".env.example",
     "tsconfig.json",
     "panda.config.ts",
-    "antigravity.md",
+    "gemini.md",
+    "claude.md",
+    "cursor.md",
     "docs"
   ],
   "scripts": {
@@ -61,23 +63,17 @@
     "access": "public"
   },
   "devDependencies": {
-    "@eslint/js": "^9.20.0",
+    "@eslint/js": "^10.0.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@pandacss/dev": "^0.53.0",
-    "@types/node": "^22.13.4",
-    "concurrently": "^9.1.2",
-    "eslint": "^9.20.1",
+    "@pandacss/dev": "^1.11.1",
+    "@types/node": "^25.9.1",
+    "concurrently": "^9.2.1",
+    "eslint": "^10.4.0",
     "ts-morph": "^28.0.0",
-    "tsx": "^4.19.4",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.59.3",
-    "vitest": "^3.0.5",
-    "zod": "^3.24.2",
-    "agent-enderun": "^0.6.8"
-  },
-  "enderun": {
-    "version": "0.6.8",
-    "initializedAt": "2026-05-24T12:00:52.687Z"
-  },
-  "dependencies": {}
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0",
+    "vitest": "^4.1.7",
+    "zod": "^3.24.2"
+  }
 }

package/.antigravitycli/BRAIN_DASHBOARD.md

@@ -1,43 +0,0 @@
-# 🧠 Agent Academy Brain Dashboard
-
-This dashboard provides a high-level overview of the Academy's performance, quality trends, and architectural health.
-
----
-
-## 📊 Performance Metrics
-
-| Metric                  | Current Value | Status       |
-| :---------------------- | :------------ | :----------- |
-| **Global Success Rate** | 0%            | ⏳ Initializing |
-| **Active Trace IDs**    | 0             | ⚪ Idle         |
-| **Agent Velocity**      | 0 tasks/day   | ⚪ Idle         |
-| **Contract Integrity**  | 100%          | ✅ Valid        |
-
----
-
-## 🛡️ Quality & Security
-
-- **Security Audit Status**: 🟢 Clean
-- **Constitution Compliance**: 🔵 100%
-- **Documentation Debt**: 🟠 Low
-
----
-
-## 🏗️ Architectural Health
-
-- **Dependency Cycles**: 0 detected.
-- **Complexity Spikes**: 0 identified.
-- **Database Migrations**: 0 pending.
-
----
-
-## 📜 Contract Change Log
-
-| Version | Date       | Description          | Hash |
-| :------ | :--------- | :------------------- | :--- |
-| v0.6.6  | 2026-05-24 | v0.6.6 Release Baseline | —    |
-
----
-
-> [!NOTE]
-> This dashboard is automatically updated by the `@analyst` agent via the `update_brain_dashboard` tool (simulated).