march-cli 0.1.21 → 0.1.23

package/src/agent/runtime/runner-runtime-host.mjs

@@ -1,79 +1,79 @@
-import { createAgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import { createMarchRuntimeFactory } from "./runtime-factory.mjs";
-import { createRuntimeHost } from "./runtime-host.mjs";
-import { resolveRunnerSessionOptions } from "../session/session-options.mjs";
-import { registerSuperGrokProvider } from "../../supergrok/provider.mjs";
-import { registerCustomProviders } from "../../provider/custom-provider.mjs";
-
-export async function createRunnerRuntimeHost({
-  cwd,
-  stateRoot,
-  provider,
-  modelId,
-  authStorage,
-  settingsManager,
-  modelRegistry,
-  providers = {},
-  sessionManager,
-  sessionBinding,
-  engine,
-  ui,
-  projectMarchDir = null,
-  memoryTools = [],
-  shellRuntime = null,
-  lspService = null,
-  mcpTools = [],
-  webTools = [],
-  permissionController = null,
-  extensionPaths = [],
-  hostedTools = {},
-  onRebind = null,
-  createAgentSessionRuntimeImpl = createAgentSessionRuntime,
-  createServices,
-  createFromServices,
-}) {
-  const createRuntime = createMarchRuntimeFactory({
-    agentDir: stateRoot,
-    authStorage,
-    settingsManager,
-    modelRegistry,
-    createServices,
-    createFromServices,
-    resourceLoaderOptions: {
-      additionalExtensionPaths: extensionPaths,
-    },
-    resolveSessionOptions: ({ cwd: sessionCwd, services }) => {
-      const activeModelRegistry = services.modelRegistry ?? modelRegistry;
-      registerSuperGrokProvider(activeModelRegistry);
-      registerCustomProviders(activeModelRegistry, providers);
-      return resolveRunnerSessionOptions({
-        cwd: sessionCwd,
-        provider,
-        modelId,
-        modelRegistry: activeModelRegistry,
-        engine,
-        ui,
-        memoryTools,
-        shellRuntime,
-        lspService,
-        mcpTools,
-        webTools,
-        permissionController,
-        authStorage,
-        projectMarchDir,
-        hostedTools,
-        getCurrentModel: () => sessionBinding.get()?.model ?? null,
-      });
-    },
-  });
-
-  const runtime = await createAgentSessionRuntimeImpl(createRuntime, {
-    cwd,
-    agentDir: stateRoot,
-    sessionManager,
-  });
-
-  const host = createRuntimeHost({ runtime, sessionBinding, onRebind });
-  if (onRebind) await onRebind(runtime.session);
-  return host;
-}
+import { createAgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { createMarchRuntimeFactory } from "./runtime-factory.mjs";
+import { createRuntimeHost } from "./runtime-host.mjs";
+import { resolveRunnerSessionOptions } from "../session/session-options.mjs";
+import { registerSuperGrokProvider } from "../../supergrok/provider.mjs";
+import { registerCustomProviders } from "../../provider/custom-provider.mjs";
+
+export async function createRunnerRuntimeHost({
+  cwd,
+  stateRoot,
+  provider,
+  modelId,
+  authStorage,
+  settingsManager,
+  modelRegistry,
+  providers = {},
+  sessionManager,
+  sessionBinding,
+  engine,
+  ui,
+  projectMarchDir = null,
+  memoryTools = [],
+  shellRuntime = null,
+  lspService = null,
+  mcpTools = [],
+  webTools = [],
+  permissionController = null,
+  extensionPaths = [],
+  hostedTools = {},
+  onRebind = null,
+  createAgentSessionRuntimeImpl = createAgentSessionRuntime,
+  createServices,
+  createFromServices,
+}) {
+  const createRuntime = createMarchRuntimeFactory({
+    agentDir: stateRoot,
+    authStorage,
+    settingsManager,
+    modelRegistry,
+    createServices,
+    createFromServices,
+    resourceLoaderOptions: {
+      additionalExtensionPaths: extensionPaths,
+    },
+    resolveSessionOptions: ({ cwd: sessionCwd, services }) => {
+      const activeModelRegistry = services.modelRegistry ?? modelRegistry;
+      registerSuperGrokProvider(activeModelRegistry);
+      registerCustomProviders(activeModelRegistry, providers);
+      return resolveRunnerSessionOptions({
+        cwd: sessionCwd,
+        provider,
+        modelId,
+        modelRegistry: activeModelRegistry,
+        engine,
+        ui,
+        memoryTools,
+        shellRuntime,
+        lspService,
+        mcpTools,
+        webTools,
+        permissionController,
+        authStorage,
+        projectMarchDir,
+        hostedTools,
+        getCurrentModel: () => sessionBinding.get()?.model ?? null,
+      });
+    },
+  });
+
+  const runtime = await createAgentSessionRuntimeImpl(createRuntime, {
+    cwd,
+    agentDir: stateRoot,
+    sessionManager,
+  });
+
+  const host = createRuntimeHost({ runtime, sessionBinding, onRebind });
+  if (onRebind) await onRebind(runtime.session);
+  return host;
+}

package/src/agent/runtime/runtime-factory.mjs

@@ -1,42 +1,42 @@
-import {
-  createAgentSessionFromServices,
-  createAgentSessionServices,
-} from "@earendil-works/pi-coding-agent";
-
-export function createMarchRuntimeFactory({
-  agentDir,
-  authStorage,
-  settingsManager,
-  modelRegistry,
-  resolveSessionOptions,
-  resourceLoaderOptions = {},
-  createServices = createAgentSessionServices,
-  createFromServices = createAgentSessionFromServices,
-}) {
-  if (typeof resolveSessionOptions !== "function") {
-    throw new Error("resolveSessionOptions is required");
-  }
-
-  return async ({ cwd, sessionManager, sessionStartEvent }) => {
-    const services = await createServices({
-      cwd,
-      agentDir,
-      authStorage,
-      settingsManager,
-      modelRegistry,
-      resourceLoaderOptions,
-    });
-    const sessionOptions = await resolveSessionOptions({ cwd, services });
-    const result = await createFromServices({
-      services,
-      sessionManager,
-      sessionStartEvent,
-      ...sessionOptions,
-    });
-    return {
-      ...result,
-      services,
-      diagnostics: services.diagnostics,
-    };
-  };
-}
+import {
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+} from "@earendil-works/pi-coding-agent";
+
+export function createMarchRuntimeFactory({
+  agentDir,
+  authStorage,
+  settingsManager,
+  modelRegistry,
+  resolveSessionOptions,
+  resourceLoaderOptions = {},
+  createServices = createAgentSessionServices,
+  createFromServices = createAgentSessionFromServices,
+}) {
+  if (typeof resolveSessionOptions !== "function") {
+    throw new Error("resolveSessionOptions is required");
+  }
+
+  return async ({ cwd, sessionManager, sessionStartEvent }) => {
+    const services = await createServices({
+      cwd,
+      agentDir,
+      authStorage,
+      settingsManager,
+      modelRegistry,
+      resourceLoaderOptions,
+    });
+    const sessionOptions = await resolveSessionOptions({ cwd, services });
+    const result = await createFromServices({
+      services,
+      sessionManager,
+      sessionStartEvent,
+      ...sessionOptions,
+    });
+    return {
+      ...result,
+      services,
+      diagnostics: services.diagnostics,
+    };
+  };
+}

package/src/agent/runtime/runtime-host.mjs

@@ -1,34 +1,34 @@
-export function createRuntimeHost({ runtime, sessionBinding, onRebind = null }) {
-  const bindSession = async (session) => {
-    sessionBinding.set(session);
-    if (onRebind) await onRebind(session);
-    return session;
-  };
-
-  runtime.setRebindSession?.(bindSession);
-  sessionBinding.set(runtime.session);
-
-  return {
-    get runtime() {
-      return runtime;
-    },
-    getSession() {
-      return sessionBinding.get();
-    },
-    getDiagnostics() {
-      return runtime.diagnostics ?? [];
-    },
-    async switchSession(sessionPath, options) {
-      return runtime.switchSession(sessionPath, options);
-    },
-    async newSession(options) {
-      return runtime.newSession(options);
-    },
-    async fork(entryId, options) {
-      return runtime.fork(entryId, options);
-    },
-    async dispose() {
-      return runtime.dispose();
-    },
-  };
-}
+export function createRuntimeHost({ runtime, sessionBinding, onRebind = null }) {
+  const bindSession = async (session) => {
+    sessionBinding.set(session);
+    if (onRebind) await onRebind(session);
+    return session;
+  };
+
+  runtime.setRebindSession?.(bindSession);
+  sessionBinding.set(runtime.session);
+
+  return {
+    get runtime() {
+      return runtime;
+    },
+    getSession() {
+      return sessionBinding.get();
+    },
+    getDiagnostics() {
+      return runtime.diagnostics ?? [];
+    },
+    async switchSession(sessionPath, options) {
+      return runtime.switchSession(sessionPath, options);
+    },
+    async newSession(options) {
+      return runtime.newSession(options);
+    },
+    async fork(entryId, options) {
+      return runtime.fork(entryId, options);
+    },
+    async dispose() {
+      return runtime.dispose();
+    },
+  };
+}

package/src/agent/runtime/ui-event-bridge.mjs

@@ -1,95 +1,95 @@
-export function createRuntimeUiEventTarget(ui) {
-  return {
-    uiEvent: (event) => dispatchRuntimeUiEvent(ui, event),
-    uiRequest: (event) => dispatchRuntimeUiEvent(ui, event),
-  };
-}
-
-export function createRuntimeUiEventBus() {
-  const listeners = new Set();
-  return {
-    on(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    emit(event) {
-      for (const listener of [...listeners]) listener(event);
-    },
-    async request(event) {
-      let response;
-      for (const listener of [...listeners]) {
-        const result = await listener(event);
-        if (response === undefined && result !== undefined) response = result;
-      }
-      return response;
-    },
-  };
-}
-
-export function createRuntimeUiBridge(ui, { eventBus = createRuntimeUiEventBus() } = {}) {
-  const detach = eventBus.on((event) => dispatchRuntimeUiEvent(ui, event));
-  return {
-    ui: createRuntimeUiClient(eventBus),
-    eventBus,
-    detach,
-  };
-}
-
-export function createRuntimeUiClient(eventBus) {
-  return {
-    turnStart: () => eventBus.emit({ type: "turn_start" }),
-    turnEnd: () => eventBus.emit({ type: "turn_end" }),
-    assistantReplyEnd: () => eventBus.emit({ type: "assistant_reply_end" }),
-    textDelta: (delta) => eventBus.emit({ type: "text_delta", delta }),
-    thinkingStart: () => eventBus.emit({ type: "thinking_start" }),
-    thinkingDelta: (delta) => eventBus.emit({ type: "thinking_delta", delta }),
-    thinkingEnd: (tokens) => eventBus.emit({ type: "thinking_end", tokens }),
-    toolStart: (name, args) => eventBus.emit({ type: "tool_start", name, args }),
-    toolEnd: (name, isError, result) => eventBus.emit({ type: "tool_end", name, isError, result }),
-    retryStart: (event) => eventBus.emit({ type: "retry_start", ...event }),
-    retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
-    status: (text) => eventBus.emit({ type: "status", text }),
-    debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
-    memoryHint: ({ source, hints }) => eventBus.emit({ type: "memory_hint", source, hints }),
-    editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
-    requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
-  };
-}
-
-export function dispatchRuntimeUiEvent(ui, event) {
-  switch (event.type) {
-    case "turn_start": return ui.turnStart?.();
-    case "turn_end": return ui.turnEnd?.();
-    case "assistant_reply_end": return ui.assistantReplyEnd?.();
-    case "text_delta": return ui.textDelta?.(event.delta);
-    case "thinking_start": return ui.thinkingStart?.();
-    case "thinking_delta": return ui.thinkingDelta?.(event.delta);
-    case "thinking_end": return ui.thinkingEnd?.(event.tokens);
-    case "tool_start": return ui.toolStart?.(event.name, event.args);
-    case "tool_end": return ui.toolEnd?.(event.name, event.isError, event.result);
-    case "retry_start": return ui.retryStart?.(pickRetryStart(event));
-    case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
-    case "status": return ui.status?.(event.text);
-    case "debug_lines": return writeDebugLines(ui, event.lines);
-    case "memory_hint": return ui.memoryHint?.({ source: event.source, hints: event.hints });
-    case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
-    case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
-    default: return undefined;
-  }
-}
-
-function writeDebugLines(ui, lines) {
-  if (!Array.isArray(lines)) return undefined;
-  if (ui?.debugLines) return ui.debugLines(lines);
-  if (!ui?.writeln) return undefined;
-  for (const line of lines) ui.writeln(line);
-  return undefined;
-}
-
-function pickRetryStart({ attempt, maxAttempts, delayMs, errorMessage }) {
-  return { attempt, maxAttempts, delayMs, errorMessage };
-}
-
-function pickRetryEnd({ success, attempt, finalError }) {
-  return { success, attempt, finalError };
-}
+export function createRuntimeUiEventTarget(ui) {
+  return {
+    uiEvent: (event) => dispatchRuntimeUiEvent(ui, event),
+    uiRequest: (event) => dispatchRuntimeUiEvent(ui, event),
+  };
+}
+
+export function createRuntimeUiEventBus() {
+  const listeners = new Set();
+  return {
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(event) {
+      for (const listener of [...listeners]) listener(event);
+    },
+    async request(event) {
+      let response;
+      for (const listener of [...listeners]) {
+        const result = await listener(event);
+        if (response === undefined && result !== undefined) response = result;
+      }
+      return response;
+    },
+  };
+}
+
+export function createRuntimeUiBridge(ui, { eventBus = createRuntimeUiEventBus() } = {}) {
+  const detach = eventBus.on((event) => dispatchRuntimeUiEvent(ui, event));
+  return {
+    ui: createRuntimeUiClient(eventBus),
+    eventBus,
+    detach,
+  };
+}
+
+export function createRuntimeUiClient(eventBus) {
+  return {
+    turnStart: () => eventBus.emit({ type: "turn_start" }),
+    turnEnd: () => eventBus.emit({ type: "turn_end" }),
+    assistantReplyEnd: () => eventBus.emit({ type: "assistant_reply_end" }),
+    textDelta: (delta) => eventBus.emit({ type: "text_delta", delta }),
+    thinkingStart: () => eventBus.emit({ type: "thinking_start" }),
+    thinkingDelta: (delta) => eventBus.emit({ type: "thinking_delta", delta }),
+    thinkingEnd: (tokens) => eventBus.emit({ type: "thinking_end", tokens }),
+    toolStart: (name, args) => eventBus.emit({ type: "tool_start", name, args }),
+    toolEnd: (name, isError, result) => eventBus.emit({ type: "tool_end", name, isError, result }),
+    retryStart: (event) => eventBus.emit({ type: "retry_start", ...event }),
+    retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
+    status: (text) => eventBus.emit({ type: "status", text }),
+    debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
+    memoryHint: ({ source, hints }) => eventBus.emit({ type: "memory_hint", source, hints }),
+    editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
+    requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
+  };
+}
+
+export function dispatchRuntimeUiEvent(ui, event) {
+  switch (event.type) {
+    case "turn_start": return ui.turnStart?.();
+    case "turn_end": return ui.turnEnd?.();
+    case "assistant_reply_end": return ui.assistantReplyEnd?.();
+    case "text_delta": return ui.textDelta?.(event.delta);
+    case "thinking_start": return ui.thinkingStart?.();
+    case "thinking_delta": return ui.thinkingDelta?.(event.delta);
+    case "thinking_end": return ui.thinkingEnd?.(event.tokens);
+    case "tool_start": return ui.toolStart?.(event.name, event.args);
+    case "tool_end": return ui.toolEnd?.(event.name, event.isError, event.result);
+    case "retry_start": return ui.retryStart?.(pickRetryStart(event));
+    case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
+    case "status": return ui.status?.(event.text);
+    case "debug_lines": return writeDebugLines(ui, event.lines);
+    case "memory_hint": return ui.memoryHint?.({ source: event.source, hints: event.hints });
+    case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
+    case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
+    default: return undefined;
+  }
+}
+
+function writeDebugLines(ui, lines) {
+  if (!Array.isArray(lines)) return undefined;
+  if (ui?.debugLines) return ui.debugLines(lines);
+  if (!ui?.writeln) return undefined;
+  for (const line of lines) ui.writeln(line);
+  return undefined;
+}
+
+function pickRetryStart({ attempt, maxAttempts, delayMs, errorMessage }) {
+  return { attempt, maxAttempts, delayMs, errorMessage };
+}
+
+function pickRetryEnd({ success, attempt, finalError }) {
+  return { success, attempt, finalError };
+}

package/src/agent/screen-tools/list-windows-tool.mjs

@@ -1,39 +1,39 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { listWindowsWindows } from "./windows-screen.mjs";
-
-export function createListWindowsTool({ listWindowsImpl = listWindowsWindows } = {}) {
-  return defineTool({
-    name: "list_windows",
-    label: "List Windows",
-    description: "List visible desktop windows so the model can choose a windowId for screen({ target: 'window', windowId }).",
-    parameters: Type.Object({
-      limit: Type.Optional(Type.Number({ description: "Maximum windows to return; default 30" })),
-    }),
-    execute: async (_toolCallId, params = {}) => listWindowsTool({ listWindowsImpl, ...params }),
-  });
-}
-
-export function listWindowsTool({ listWindowsImpl = listWindowsWindows, limit = 30 } = {}) {
-  const result = listWindowsImpl();
-  if (!result?.ok) return textResult(`Error listing windows: ${result?.message || "unknown error"}`, { error: true });
-  const windows = (result.windows ?? []).slice(0, normalizeLimit(limit));
-  if (windows.length === 0) return textResult("No visible windows found.", { windows: [] });
-  const lines = ["Visible windows:"];
-  for (const item of windows) {
-    const process = item.process ? ` (${item.process})` : "";
-    const bounds = item.bounds ? ` ${item.bounds.width}x${item.bounds.height}+${item.bounds.x},${item.bounds.y}` : "";
-    const minimized = item.minimized ? " minimized" : "";
-    lines.push(`- ${item.id}${process}${bounds}${minimized}: ${item.title}`);
-  }
-  lines.push("Use screen({ target: 'window', windowId }) to capture a listed window.");
-  return textResult(lines.join("\n"), { windows });
-}
-
-function normalizeLimit(limit) {
-  return Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), 100) : 30;
-}
-
-function textResult(text, details = {}) {
-  return { content: [{ type: "text", text }], details };
-}
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { listWindowsWindows } from "./windows-screen.mjs";
+
+export function createListWindowsTool({ listWindowsImpl = listWindowsWindows } = {}) {
+  return defineTool({
+    name: "list_windows",
+    label: "List Windows",
+    description: "List visible desktop windows so the model can choose a windowId for screen({ target: 'window', windowId }).",
+    parameters: Type.Object({
+      limit: Type.Optional(Type.Number({ description: "Maximum windows to return; default 30" })),
+    }),
+    execute: async (_toolCallId, params = {}) => listWindowsTool({ listWindowsImpl, ...params }),
+  });
+}
+
+export function listWindowsTool({ listWindowsImpl = listWindowsWindows, limit = 30 } = {}) {
+  const result = listWindowsImpl();
+  if (!result?.ok) return textResult(`Error listing windows: ${result?.message || "unknown error"}`, { error: true });
+  const windows = (result.windows ?? []).slice(0, normalizeLimit(limit));
+  if (windows.length === 0) return textResult("No visible windows found.", { windows: [] });
+  const lines = ["Visible windows:"];
+  for (const item of windows) {
+    const process = item.process ? ` (${item.process})` : "";
+    const bounds = item.bounds ? ` ${item.bounds.width}x${item.bounds.height}+${item.bounds.x},${item.bounds.y}` : "";
+    const minimized = item.minimized ? " minimized" : "";
+    lines.push(`- ${item.id}${process}${bounds}${minimized}: ${item.title}`);
+  }
+  lines.push("Use screen({ target: 'window', windowId }) to capture a listed window.");
+  return textResult(lines.join("\n"), { windows });
+}
+
+function normalizeLimit(limit) {
+  return Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), 100) : 30;
+}
+
+function textResult(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}