cortex-agents 4.1.2 → 5.0.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { CortexCodeBridge } from "./utils/cortex-code-bridge.js";
 // Import all tool modules
 import * as cortex from "./tools/cortex";
 import * as worktree from "./tools/worktree";
@@ -9,6 +10,7 @@ import * as task from "./tools/task";
 import * as github from "./tools/github";
 import * as repl from "./tools/repl";
 import * as qualityGate from "./tools/quality-gate";
+import * as engineTools from "./tools/engine";
 // ─── Agent Descriptions (for handover toasts) ───────────────────────────────
 const AGENT_DESCRIPTIONS = {
     implement: "Development mode — ready to implement",
@@ -149,6 +151,7 @@ function extractErrorMessage(error) {
 }
 // ─── Plugin Entry ────────────────────────────────────────────────────────────
 export const CortexPlugin = async (ctx) => {
+    const bridge = new CortexCodeBridge();
     return {
         tool: {
             // Cortex tools - .cortex directory management
@@ -193,6 +196,9 @@ export const CortexPlugin = async (ctx) => {
             repl_summary: repl.summary,
             // Quality gate aggregation tool
             quality_gate_summary: qualityGate.qualityGateSummary,
+            // Engine-backed tools
+            cortex_get_skill: engineTools.getSkill,
+            cortex_list_agents: engineTools.listAgents,
         },
         // ── Post-execution toast notifications ────────────────────────────────
         //
@@ -235,6 +241,53 @@ export const CortexPlugin = async (ctx) => {
         },
         // ── Event-driven notifications ───────────────────────────────────────
         async event({ event }) {
+            // ── Cortex Code bridge (fire-and-forget, no-op outside Cortex Code) ──
+            if (bridge.isActive) {
+                // session.status busy → agent started working
+                if (event.type === "session.status" &&
+                    event.properties.status.type === "busy") {
+                    bridge.taskStarted();
+                }
+                // session.status idle → agent waiting for user input
+                if (event.type === "session.status" &&
+                    event.properties.status.type === "idle") {
+                    bridge.interactionNeeded("input");
+                }
+                // session.idle → all processing complete
+                if (event.type === "session.idle") {
+                    bridge.taskFinished();
+                }
+                // session.error → forward error
+                if (event.type === "session.error") {
+                    const rawError = event.properties.error;
+                    const error = rawError &&
+                        typeof rawError === "object" &&
+                        "name" in rawError &&
+                        typeof rawError.name === "string"
+                        ? rawError
+                        : undefined;
+                    bridge.error(extractErrorMessage(error));
+                }
+                // message.part.updated — text content
+                if (event.type === "message.part.updated" &&
+                    event.properties.part.type === "text") {
+                    bridge.text(event.properties.part.text);
+                }
+                // message.part.updated — tool call
+                if (event.type === "message.part.updated" &&
+                    event.properties.part.type === "tool") {
+                    const part = event.properties.part;
+                    bridge.toolCall(part.callID, part.tool, part.metadata);
+                }
+                // message.updated — token/cost tracking (assistant messages with usage)
+                if (event.type === "message.updated" &&
+                    event.properties.info.role === "assistant") {
+                    const msg = event.properties.info;
+                    if ("tokens" in msg && msg.tokens) {
+                        bridge.usage(msg.tokens.input ?? 0, msg.tokens.output ?? 0, msg.cost ?? 0, "modelID" in msg ? msg.modelID : undefined);
+                    }
+                }
+            }
             try {
                 // Agent handover notifications
                 if (event.type === "message.part.updated" &&

package/dist/tools/engine.d.ts

@@ -0,0 +1,22 @@
+export declare const getSkill: {
+    description: string;
+    args: {
+        skillId: import("zod").ZodString;
+    };
+    execute(args: {
+        skillId: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const listAgents: {
+    description: string;
+    args: {
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            primary: "primary";
+            subagent: "subagent";
+        }>>;
+    };
+    execute(args: {
+        mode?: "primary" | "subagent" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=engine.d.ts.map

package/dist/tools/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/tools/engine.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,QAAQ;;;;;;;;CAoBnB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;CA4BrB,CAAC"}

package/dist/tools/engine.js

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// Engine-backed MCP tools: cortex_get_skill, cortex_list_agents
+// ---------------------------------------------------------------------------
+import { tool } from "@opencode-ai/plugin";
+import { CortexEngine } from "../engine/index.js";
+let _engine = null;
+function getEngine() {
+    if (!_engine) {
+        _engine = new CortexEngine();
+        _engine.initialize();
+    }
+    return _engine;
+}
+export const getSkill = tool({
+    description: "Retrieve the full content of a domain skill by ID. Returns the skill markdown including guidelines, patterns, and best practices.",
+    args: {
+        skillId: tool.schema
+            .string()
+            .describe('The skill identifier, e.g. "security-hardening", "api-design"'),
+    },
+    async execute(args) {
+        const engine = getEngine();
+        const content = engine.getSkillContent(args.skillId);
+        if (!content) {
+            const skills = engine.listSkills();
+            const available = skills.map((s) => s.id).join(", ");
+            return `✗ Skill not found: ${args.skillId}\n\nAvailable skills: ${available}`;
+        }
+        return content;
+    },
+});
+export const listAgents = tool({
+    description: "List all registered agents with their mode (primary/subagent), description, and available tools.",
+    args: {
+        mode: tool.schema
+            .enum(["primary", "subagent"])
+            .optional()
+            .describe("Filter by agent mode"),
+    },
+    async execute(args) {
+        const engine = getEngine();
+        const filter = args.mode ? { mode: args.mode } : undefined;
+        const agents = engine.listAgents(filter);
+        if (agents.length === 0) {
+            return "✗ No agents found in the database. Run 'npx cortex-agents install' first.";
+        }
+        const lines = agents.map((a) => {
+            const tools = engine.getAgentTools(a.id);
+            const enabledTools = tools
+                .filter((t) => t.allowed)
+                .map((t) => t.tool_name);
+            return `- **${a.id}** (${a.mode}) — ${a.description}\n  Tools: ${enabledTools.join(", ") || "none"}`;
+        });
+        return `✓ ${agents.length} agents:\n\n${lines.join("\n\n")}`;
+    },
+});

package/dist/utils/cortex-code-bridge.d.ts

@@ -0,0 +1,21 @@
+export declare class CortexCodeBridge {
+    private readonly eventUrl;
+    private readonly taskId;
+    private readonly active;
+    private tokensIn;
+    private tokensOut;
+    private costUsd;
+    private sessionStartTime;
+    private started;
+    constructor();
+    get isActive(): boolean;
+    taskStarted(): void;
+    taskFinished(): void;
+    usage(tokensIn: number, tokensOut: number, costUsd: number, model?: string): void;
+    interactionNeeded(reason: string, prompt?: string): void;
+    text(content: string): void;
+    toolCall(id: string, name: string, input?: unknown): void;
+    error(message: string, code?: string, recoverable?: boolean): void;
+    private send;
+}
+//# sourceMappingURL=cortex-code-bridge.d.ts.map

package/dist/utils/cortex-code-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cortex-code-bridge.d.ts","sourceRoot":"","sources":["../../src/utils/cortex-code-bridge.ts"],"names":[],"mappings":"AAgBA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IAGjC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IAEpB,OAAO,CAAC,gBAAgB,CAAc;IACtC,OAAO,CAAC,OAAO,CAAS;;IAUxB,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAID,WAAW,IAAI,IAAI;IAOnB,YAAY,IAAI,IAAI;IAUpB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAYjF,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAOxD,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI3B,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI;IAQzD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI;IAUlE,OAAO,CAAC,IAAI;CAkBb"}

package/dist/utils/cortex-code-bridge.js

@@ -0,0 +1,104 @@
+// ─── Cortex Code Event Bridge ─────────────────────────────────────────────────
+//
+// When running inside Cortex Code's embedded terminal, the environment provides:
+//   CORTEX_EVENT_URL  — HTTP endpoint for structured events
+//   CORTEX_TASK_ID    — ID of the parent task in Cortex Code
+//   CORTEX_CODE       — "1" when running inside Cortex Code
+//
+// This bridge POSTs structured events so Cortex Code can precisely track agent
+// state (working, waiting, finished) instead of relying on ANSI heuristics.
+//
+// Payload format (Cortex Event Protocol):
+//   { cortex: "event", taskId, type, timestamp, ...fields }
+//
+// All HTTP calls are fire-and-forget with a 5s timeout — they never block the
+// agent or throw errors.
+export class CortexCodeBridge {
+    eventUrl;
+    taskId;
+    active;
+    // Accumulated usage for task_finished summary
+    tokensIn = 0;
+    tokensOut = 0;
+    costUsd = 0;
+    sessionStartTime = Date.now();
+    started = false;
+    constructor() {
+        this.eventUrl = process.env.CORTEX_EVENT_URL;
+        this.taskId = process.env.CORTEX_TASK_ID;
+        const cortexCode = process.env.CORTEX_CODE;
+        this.active = !!(this.eventUrl && this.taskId && cortexCode);
+    }
+    get isActive() {
+        return this.active;
+    }
+    // ── Event Senders ─────────────────────────────────────────────────────────
+    taskStarted() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.sessionStartTime = Date.now();
+        this.send("task_started", {});
+    }
+    taskFinished() {
+        const duration = Date.now() - this.sessionStartTime;
+        this.send("task_finished", {
+            tokensIn: this.tokensIn,
+            tokensOut: this.tokensOut,
+            costUsd: this.costUsd,
+            duration,
+        });
+    }
+    usage(tokensIn, tokensOut, costUsd, model) {
+        this.tokensIn += tokensIn;
+        this.tokensOut += tokensOut;
+        this.costUsd += costUsd;
+        this.send("usage", {
+            tokensIn,
+            tokensOut,
+            costUsd,
+            ...(model ? { model } : {}),
+        });
+    }
+    interactionNeeded(reason, prompt) {
+        this.send("interaction_needed", {
+            reason,
+            ...(prompt ? { prompt } : {}),
+        });
+    }
+    text(content) {
+        this.send("text", { content });
+    }
+    toolCall(id, name, input) {
+        this.send("tool_call", {
+            id,
+            name,
+            ...(input !== undefined ? { input } : {}),
+        });
+    }
+    error(message, code, recoverable) {
+        this.send("error", {
+            message,
+            ...(code ? { code } : {}),
+            ...(recoverable !== undefined ? { recoverable } : {}),
+        });
+    }
+    // ── Internal ──────────────────────────────────────────────────────────────
+    send(type, fields) {
+        if (!this.active)
+            return;
+        const payload = {
+            cortex: "event",
+            taskId: this.taskId,
+            type,
+            timestamp: Date.now(),
+            ...fields,
+        };
+        fetch(this.eventUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(5000),
+        }).catch(() => { });
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cortex-agents",
-  "version": "4.1.2",
-  "description": "Supercharge OpenCode with structured workflows, intelligent agents, and automated development practices",
+  "version": "5.0.0",
+  "description": "Structured AI development workflows for OpenCode and Claude Code — plan, build, ship with discipline",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -55,12 +55,14 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.0.0",
     "@types/prompts": "^2.4.9",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"
   },
   "dependencies": {
+    "better-sqlite3": "^12.6.2",
     "prompts": "^2.4.2"
   }
 }