pi-codemcp 1.4.0 → 1.5.1

package/src/settings.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { readJsonObject, requireJsonObject, writeJsonObjectAtomically } from "./json-file.js";
 
 export interface CodeMcpSettings {
+  jevEnabled: boolean;
   backgroundWarmup: boolean;
   cacheTtlHours: number;
   executionTimeoutSeconds: number;
@@ -16,6 +17,7 @@ export type EditableSettingKey = Exclude<keyof CodeMcpSettings, "disabledTools">
 export type EditableSettingValue = boolean | number;
 
 export const DEFAULT_CODEMCP_SETTINGS: Readonly<CodeMcpSettings> = {
+  jevEnabled: false,
   backgroundWarmup: true,
   cacheTtlHours: 24,
   executionTimeoutSeconds: 30,
@@ -28,6 +30,7 @@ export const DEFAULT_CODEMCP_SETTINGS: Readonly<CodeMcpSettings> = {
 
 const ALLOWED_KEYS = new Set([
   "version",
+  "jevEnabled",
   "backgroundWarmup",
   "cacheTtlHours",
   "executionTimeoutSeconds",
@@ -45,16 +48,18 @@ export function loadCodeMcpSettings(path: string): CodeMcpSettings {
   if (version !== 1 && version !== 2) {
     throw new Error(`Unsupported CodeMCP settings version: ${String(version)}`);
   }
-  const migrated =
+  const versionMigrated =
     version === 1
       ? Object.fromEntries(Object.entries(root).filter(([key]) => key !== "outputLineLimit"))
       : root;
+  const migrated = migrateDiscoveryMode(versionMigrated);
   const unknown = Object.keys(migrated).filter((key) => !ALLOWED_KEYS.has(key));
   if (unknown.length > 0) {
     throw new Error(`Unknown CodeMCP settings: ${unknown.join(", ")}`);
   }
 
   return {
+    jevEnabled: booleanSetting(migrated, "jevEnabled"),
     backgroundWarmup: booleanSetting(migrated, "backgroundWarmup"),
     cacheTtlHours: integerSetting(migrated, "cacheTtlHours", 0, 720),
     executionTimeoutSeconds: integerSetting(migrated, "executionTimeoutSeconds", 1, 300),
@@ -69,6 +74,7 @@ export function loadCodeMcpSettings(path: string): CodeMcpSettings {
 export function saveCodeMcpSettings(path: string, settings: CodeMcpSettings): void {
   writeJsonObjectAtomically(path, {
     version: 2,
+    jevEnabled: settings.jevEnabled,
     backgroundWarmup: settings.backgroundWarmup,
     cacheTtlHours: settings.cacheTtlHours,
     executionTimeoutSeconds: settings.executionTimeoutSeconds,
@@ -85,7 +91,7 @@ export function setEditableSetting(
   key: EditableSettingKey,
   value: EditableSettingValue,
 ): CodeMcpSettings {
-  if (key === "backgroundWarmup") {
+  if (key === "jevEnabled" || key === "backgroundWarmup") {
     if (typeof value !== "boolean") throw new TypeError(`${key} must be a boolean`);
     return { ...settings, [key]: value };
   }
@@ -112,7 +118,21 @@ function cloneDefaults(): CodeMcpSettings {
   return { ...DEFAULT_CODEMCP_SETTINGS, disabledTools: {} };
 }
 
-function booleanSetting(root: Record<string, unknown>, key: "backgroundWarmup"): boolean {
+function migrateDiscoveryMode(root: Record<string, unknown>): Record<string, unknown> {
+  if (root.discoveryMode === undefined) return root;
+  if (root.discoveryMode !== "search" && root.discoveryMode !== "jev") {
+    throw new TypeError("discoveryMode must be search or jev");
+  }
+  return {
+    ...Object.fromEntries(Object.entries(root).filter(([key]) => key !== "discoveryMode")),
+    jevEnabled: root.jevEnabled ?? root.discoveryMode === "jev",
+  };
+}
+
+function booleanSetting(
+  root: Record<string, unknown>,
+  key: "jevEnabled" | "backgroundWarmup",
+): boolean {
   const value = root[key] ?? DEFAULT_CODEMCP_SETTINGS[key];
   if (typeof value !== "boolean") throw new TypeError(`${key} must be a boolean`);
   return value;
@@ -120,7 +140,7 @@ function booleanSetting(root: Record<string, unknown>, key: "backgroundWarmup"):
 
 function integerSetting(
   root: Record<string, unknown>,
-  key: Exclude<EditableSettingKey, "backgroundWarmup">,
+  key: Exclude<EditableSettingKey, "jevEnabled" | "backgroundWarmup">,
   minimum: number,
   maximum: number,
 ): number {

package/src/tools.ts

@@ -12,7 +12,9 @@ import {
   previewExecutionValue,
   renderExecutionResult,
 } from "./execution-rendering.js";
+import type { JevRouter } from "./jev-router.js";
 import type { CodeMcpLifecycle } from "./lifecycle.js";
+import type { SidecarProgress } from "./mcp-client.js";
 import { type CodeMcpOutputDetails, formatCodeMcpOutput } from "./output.js";
 import {
   EXECUTE_PROMPT_GUIDELINES,
@@ -73,6 +75,15 @@ const SearchParameters = Type.Object({
   ),
 });
 
+const JevRouteParameters = Type.Object({
+  intent: Type.String({
+    minLength: 1,
+    pattern: "\\S",
+    description:
+      "Briefly describe the current MCP subtask and relevant service or environment, e.g. read staging logs to diagnose an approval error. Not instructions to another agent; the original user request is included automatically.",
+  }),
+});
+
 const InspectParameters = Type.Object({
   calls: Type.Array(Type.String({ minLength: 1 }), {
     minItems: 1,
@@ -162,6 +173,80 @@ const EditExecuteParameters = Type.Object({
   }),
 });
 
+export function registerJevRouteTool(
+  pi: ExtensionAPI,
+  getRouter: () => Pick<JevRouter, "route"> | undefined,
+): void {
+  pi.registerTool({
+    name: "codemcp_route",
+    label: "Jev MCP Route",
+    description:
+      "Use Jev to select configured MCP calls for the agent's current subtask, including prerequisites, classify each call's workflow role, recommend parallel or dependent composition, and return exact typed SDK contracts. Use when the subtask may require external services or saved workflows. If no configured capability applies, returns no calls.",
+    promptSnippet: "Select MCP calls and composition guidance for the current subtask with Jev",
+    promptGuidelines: [
+      "Use codemcp_route once per distinct MCP subtask. Provide a short intent describing what you need now, including relevant findings; the original user request and recent context are included automatically. Route again with an updated intent if the subtask changes or the selected contracts cannot complete it.",
+      "After codemcp_route returns contracts, immediately write and run the recommended minimal codemcp_execute program instead of stopping to describe the plan.",
+      "Follow codemcp_route composition guidance: gather independent calls, sequence dependent calls, and preserve a model turn only for semantic decisions or approvals.",
+    ],
+    parameters: JevRouteParameters,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const router = getRouter();
+      if (!router) throw new Error("Jev routing requires TYPESAFE_API_KEY");
+      const { task, recentContext } = currentRouteTask(ctx.sessionManager.buildContextEntries());
+      onUpdate?.({
+        content: [{ type: "text", text: "Jev is selecting and composing MCP calls..." }],
+        details: undefined,
+      });
+      try {
+        const route = await router.route(
+          params.intent,
+          [`Original user request: ${task}`, recentContext].filter(Boolean).join("\n\n"),
+          signal,
+        );
+        return {
+          content: [{ type: "text", text: route.prompt }],
+          details: {
+            selected: route.selected.map((tool) => ({
+              call: tool.call,
+              relevance: tool.relevance,
+              role: tool.role,
+            })),
+            needsAnyTool: route.needsAnyTool,
+            workflowShape: route.workflowShape,
+            needsCheckpoint: route.needsCheckpoint,
+          },
+        };
+      } catch (error) {
+        const active = pi.getActiveTools();
+        if (!active.includes("codemcp_search")) {
+          pi.setActiveTools([...active, "codemcp_search"]);
+        }
+        throw error;
+      }
+    },
+    renderCall(_args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("Jev MCP Route")), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Jev is routing..."), 0, 0);
+      if (expanded) return renderExpandedJson(result.content);
+      const details = result.details as
+        | { selected?: Array<{ call?: string }>; workflowShape?: string }
+        | undefined;
+      const selected = details?.selected ?? [];
+      let text = theme.fg(
+        "success",
+        `\n${selected.length} calls · ${details?.workflowShape ?? "no workflow"}`,
+      );
+      for (const tool of selected.slice(0, 4)) {
+        if (tool.call) text += `\n${theme.fg("dim", `  ${tool.call}`)}`;
+      }
+      text += `\n${theme.fg("muted", keyHint("app.tools.expand", "routing details"))}`;
+      return new Text(text, 0, 0);
+    },
+  });
+}
+
 export function registerCodeMcpTools(
   pi: ExtensionAPI,
   lifecycle: CodeMcpLifecycle,
@@ -330,6 +415,7 @@ export function registerCodeMcpTools(
           ...(params.inputRef === undefined ? {} : { input_ref: params.inputRef }),
         },
         signal,
+        (progress) => onUpdate?.(executionProgressUpdate(progress)),
       );
       return formatExecutionResponse(result, lifecycle);
     },
@@ -384,6 +470,7 @@ export function registerCodeMcpTools(
           trace_id: toolCallId,
         },
         signal,
+        (progress) => onUpdate?.(executionProgressUpdate(progress)),
       );
       return formatExecutionResponse(result, lifecycle);
     },
@@ -577,6 +664,17 @@ export function registerCodeMcpTools(
   });
 }
 
+function executionProgressUpdate(progress: SidecarProgress) {
+  const currentCall = progress.message === "executing" ? undefined : progress.message;
+  return {
+    content: [{ type: "text" as const, text: progress.message ?? "Executing MCP calls..." }],
+    details: {
+      callsMade: progress.progress,
+      ...(currentCall === undefined ? {} : { currentCall }),
+    },
+  };
+}
+
 function formatExecutionResponse(result: Record<string, unknown>, lifecycle: CodeMcpLifecycle) {
   const ok = result.ok === true;
   const modelValue = ok
@@ -636,6 +734,40 @@ function outputLimits(lifecycle: CodeMcpLifecycle): { maxBytes: number } {
   return { maxBytes: settings.outputLimitKiB * 1024 };
 }
 
+function currentRouteTask(entries: readonly unknown[]): {
+  task: string;
+  recentContext: string;
+} {
+  const messages: Array<{ role: "user" | "assistant"; text: string }> = [];
+  for (const entry of entries) {
+    if (!isRecord(entry) || !isRecord(entry.message)) continue;
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const text = messageText(entry.message.content).trim();
+    if (text) messages.push({ role, text });
+  }
+  let currentIndex = messages.length - 1;
+  while (currentIndex >= 0 && messages[currentIndex]?.role !== "user") currentIndex -= 1;
+  const current = messages[currentIndex];
+  if (!current) throw new Error("Jev routing requires a text user request");
+  const recentContext = messages
+    .slice(Math.max(0, currentIndex - 3), currentIndex)
+    .map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text}`)
+    .join("\n\n")
+    .slice(-6_000);
+  return { task: current.text, recentContext };
+}
+
+function messageText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((item) =>
+      isRecord(item) && item.type === "text" && typeof item.text === "string" ? [item.text] : [],
+    )
+    .join("\n");
+}
+
 function truncate(value: string, maxLength: number): string {
   return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}…`;
 }