@cydm/pie 1.0.13 → 1.0.14

package/dist/cli.js

@@ -43943,7 +43943,7 @@ import * as path26 from "path";
 
 // src/cli-args.ts
 var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--session-id", "--extension-path"]);
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--raw-output", "--json-output"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--raw-output", "--json-output", "--json-events"]);
 var HELP_FLAGS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
 var COMMANDS = /* @__PURE__ */ new Set(["chat", "help"]);
 function parseCliInvocation(args) {
@@ -67520,6 +67520,538 @@ async function runPrintMode(params) {
   sessionTrace.flush();
 }
 
+// src/app/json-events-mode.ts
+import readline from "node:readline";
+var MAX_EVENT_OBJECT_KEYS = 50;
+var MAX_EVENT_ARRAY_ITEMS = 50;
+var MAX_EVENT_VALUE_DEPTH = 4;
+var MAX_EVENT_STRING_LENGTH = 4e3;
+function createNoOpExtensionUIContext2() {
+  return {
+    notify: () => {
+    },
+    select: async () => void 0,
+    confirm: async () => false,
+    input: async () => void 0,
+    editor: async () => void 0,
+    custom: async () => void 0
+  };
+}
+function writeEvent(event) {
+  process.stdout.write(`${JSON.stringify(event)}
+`);
+}
+function toJsonValue(value, depth = 0) {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    return value.length > MAX_EVENT_STRING_LENGTH ? `${value.slice(0, MAX_EVENT_STRING_LENGTH)}...` : value;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "boolean") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value !== "object") return void 0;
+  if (depth >= MAX_EVENT_VALUE_DEPTH) return "[truncated]";
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_EVENT_ARRAY_ITEMS).map((item) => toJsonValue(item, depth + 1) ?? null);
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value).slice(0, MAX_EVENT_OBJECT_KEYS)) {
+    result[key] = toJsonValue(item, depth + 1);
+  }
+  return result;
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseInput(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord3(parsed) || typeof parsed.type !== "string") return null;
+  if (parsed.type === "shutdown") {
+    return { type: "shutdown", reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
+  }
+  if (parsed.type === "turn.interrupt") {
+    return {
+      type: "turn.interrupt",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      turnId: typeof parsed.turnId === "string" ? parsed.turnId : void 0,
+      reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+    };
+  }
+  if (parsed.type === "turn.request" && typeof parsed.turnId === "string" && typeof parsed.prompt === "string") {
+    return {
+      type: "turn.request",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      turnId: parsed.turnId,
+      prompt: parsed.prompt,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0,
+      metadata: isRecord3(parsed.metadata) ? parsed.metadata : void 0
+    };
+  }
+  return null;
+}
+function assistantTextFromAgent(agent) {
+  const messages = agent?.state.messages ?? [];
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage?.role !== "assistant") return "";
+  let text = "";
+  for (const content of lastMessage.content) {
+    if (content.type === "text") {
+      text += content.text;
+    }
+  }
+  return text;
+}
+function readProgressText(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractJsonEventsToolProgressText(partialResult) {
+  const plainText = readProgressText(partialResult).trim();
+  if (plainText) return plainText;
+  if (!isRecord3(partialResult)) return "";
+  const content = partialResult.content;
+  if (Array.isArray(content)) {
+    return content.map((block) => isRecord3(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
+  }
+  const directText = readProgressText(partialResult.text) || readProgressText(partialResult.message);
+  if (directText) return directText.trim();
+  const details = partialResult.details;
+  if (isRecord3(details)) {
+    return (readProgressText(details.text) || readProgressText(details.message)).trim();
+  }
+  return "";
+}
+async function loadJsonModeExtensions(params) {
+  const uiContext = createNoOpExtensionUIContext2();
+  const executionState = new ExecutionStateManager();
+  const activeSession = params.runtime.sessionManager.getActiveSession();
+  executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+  const actions = {
+    setActiveTools: (toolNames) => {
+      const agent = params.getAgent();
+      if (!agent) return;
+      agent.state.tools = agent.state.tools.filter((tool) => toolNames.includes(tool.name));
+    },
+    getActiveTools: () => params.getAgent()?.state.tools.map((tool) => tool.name) ?? [],
+    sendUserMessage: () => {
+    },
+    setPlanMode: () => {
+    },
+    setExecutionReminder: (text) => {
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (!session) return;
+      if (text) {
+        session.metadata.executionReminder = text;
+      } else {
+        delete session.metadata.executionReminder;
+      }
+    },
+    getExecutionState: () => executionState.read(),
+    setExecutionState: (state) => {
+      const nextState = executionState.replace(state);
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (session) {
+        session.metadata.executionState = executionState.createMetadata();
+      }
+      return nextState;
+    },
+    cwd: params.runtime.cwd,
+    apiKey: params.runtime.apiKey,
+    model: params.runtime.model,
+    skills: params.runtime.skills,
+    getAllTools: () => params.getAgent()?.state.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    })) ?? [],
+    getRuntimeTools: () => params.getAgent()?.state.tools ?? [],
+    resolveModelClass: (modelClass) => params.runtime.modelRegistry.resolveModelClass(modelClass),
+    getMessages: () => params.getAgent()?.state.messages ?? [],
+    getSessionMetadata: () => ({ ...params.runtime.sessionManager.getActiveSession()?.metadata ?? {} }),
+    setSessionMetadata: (key, value) => {
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (!session) return;
+      session.metadata[key] = value;
+    },
+    yoloMode: false
+  };
+  const { extensions } = await loadExtensions(
+    params.runtime.extensionPaths,
+    params.runtime.cwd,
+    uiContext,
+    () => params.getAgent()?.abort(),
+    () => true,
+    false,
+    actions
+  );
+  const runner = new ExtensionRunner(
+    extensions,
+    actions,
+    {
+      isIdle: () => true,
+      abort: () => params.getAgent()?.abort()
+    },
+    false
+  );
+  runner.setUIContext(uiContext);
+  return {
+    runner,
+    extensionTools: convertExtensionTools(extensions),
+    extensionCount: extensions.length
+  };
+}
+async function runJsonEventsMode(params) {
+  const sessionId = params.explicitSessionId || params.runtime?.sessionManager.getActiveSession()?.id || `pie-json-${Date.now()}`;
+  let activeTurn = null;
+  let agent;
+  let controller;
+  let disposeAgentSubscription;
+  let disposeSemanticSubscription;
+  let trace;
+  const noProgressTimeoutMs = Number(process.env.PIE_JSON_EVENTS_NO_PROGRESS_MS || 6e5);
+  const mockResponseDelayMs = Number(process.env.PIE_TEST_MOCK_RESPONSE_DELAY_MS || 0);
+  writeEvent({ type: "agent.ready", sessionId });
+  function sessionMismatchError(requestedSessionId) {
+    return `session mismatch: JSON events process is bound to ${sessionId}, received ${requestedSessionId}`;
+  }
+  function isSessionMismatch(message) {
+    return typeof message.sessionId === "string" && message.sessionId !== sessionId;
+  }
+  function delay(ms) {
+    return new Promise((resolve4) => setTimeout(resolve4, Math.max(0, ms)));
+  }
+  function touch() {
+    if (activeTurn) {
+      activeTurn.lastActivityAt = Date.now();
+    }
+  }
+  function display(chunk) {
+    if (!activeTurn || !chunk) return;
+    activeTurn.summary += chunk;
+    touch();
+    writeEvent({
+      type: "display.output",
+      sessionId: activeTurn.sessionId,
+      turnId: activeTurn.turnId,
+      stream: "terminal",
+      chunk
+    });
+  }
+  function finalize(kind, detail) {
+    const turn = activeTurn;
+    if (!turn || turn.finalized) return;
+    turn.finalized = true;
+    switch (kind) {
+      case "completed":
+        writeEvent({ type: "turn.completed", sessionId: turn.sessionId, turnId: turn.turnId, summary: turn.summary.trim() });
+        break;
+      case "failed":
+        writeEvent({ type: "turn.failed", sessionId: turn.sessionId, turnId: turn.turnId, error: detail || "turn failed" });
+        break;
+      case "cancelled":
+        writeEvent({ type: "turn.cancelled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "interrupted" });
+        break;
+      case "stalled":
+        writeEvent({ type: "turn.stalled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "no_progress_timeout" });
+        break;
+    }
+  }
+  function handleSemanticEvent(event) {
+    if (!activeTurn || activeTurn.finalized) return;
+    switch (event.type) {
+      case "assistant_response_delta":
+        display(event.delta);
+        break;
+      case "tool_started":
+        touch();
+        writeEvent({
+          type: "tool.started",
+          sessionId: activeTurn.sessionId,
+          turnId: activeTurn.turnId,
+          toolCallId: event.toolCallId,
+          name: event.toolName,
+          data: toJsonValue({ args: event.args })
+        });
+        break;
+      case "tool_progressed":
+        touch();
+        {
+          const progressText = extractJsonEventsToolProgressText(event.partialResult);
+          if (progressText) {
+            display(progressText.endsWith("\n") ? progressText : `${progressText}
+`);
+          }
+        }
+        break;
+      case "tool_finished":
+        touch();
+        writeEvent({
+          type: "tool.completed",
+          sessionId: activeTurn.sessionId,
+          turnId: activeTurn.turnId,
+          toolCallId: event.toolCallId,
+          name: event.toolName,
+          status: event.isError ? "error" : "ok",
+          data: toJsonValue({
+            resultText: extractJsonEventsToolProgressText(event.result),
+            isError: event.isError
+          })
+        });
+        break;
+    }
+  }
+  async function ensureRuntime() {
+    if (params.mockResponse !== void 0 || controller) return;
+    const runtime = params.runtime;
+    if (!runtime) {
+      throw new Error("JSON events mode requires a CLI runtime");
+    }
+    if (runtime.initialModel.unconfigured) {
+      return;
+    }
+    const { Agent: AgentClass } = await import("./chunks/src-LZC56DRG.js");
+    const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
+    const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
+    recordCliCompositionStep(runtime.compositionTrace, {
+      id: "extensions_tool_wrapping",
+      inputSummary: `baseTools=${runtime.tools.length} extensionPaths=${runtime.extensionPaths.length}`,
+      outputSummary: `extensions=${jsonModeExtensions.extensionCount}`,
+      toolCount: tools.length,
+      extensionWrapping: {
+        extensionCount: jsonModeExtensions.extensionCount,
+        extensionToolCount: jsonModeExtensions.extensionTools.length,
+        wrappedToolCount: tools.length
+      }
+    });
+    const baseSystemPrompt = buildCliSystemPrompt({
+      cwd: runtime.cwd,
+      skillsSection: runtime.skillsSection,
+      knowledgeSection: runtime.knowledgeSection,
+      tools: tools.map((tool) => ({ name: tool.name, description: tool.description }))
+    });
+    agent = new AgentClass({
+      initialState: {
+        systemPrompt: baseSystemPrompt,
+        model: runtime.model,
+        tools,
+        thinkingLevel: "off"
+      },
+      apiKey: runtime.apiKey
+    });
+    controller = new AgentSessionController({
+      agent,
+      sessionManager: runtime.sessionManager,
+      cwd: runtime.cwd,
+      baseSystemPrompt,
+      prepareTurn: async (context) => {
+        const result = await jsonModeExtensions.runner.emitBeforeAgentStart({
+          type: "before_agent_start",
+          messages: context.messages,
+          baseSystemPrompt: context.baseSystemPrompt ?? baseSystemPrompt,
+          source: context.source
+        });
+        return {
+          systemPrompt: result?.systemPrompt ?? context.baseSystemPrompt ?? baseSystemPrompt,
+          messages: result?.messages?.length ? [...context.messages, ...result.messages] : context.messages
+        };
+      }
+    });
+    trace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
+    attachAgentEventsToSessionTrace({ agent, trace });
+    agent.setTools(wrapToolsWithExtensions(agent.state.tools, jsonModeExtensions.runner));
+    controller.updateRuntimeContext({ tools: agent.state.tools });
+    disposeSemanticSubscription = agent.subscribeSemantic(handleSemanticEvent);
+  }
+  async function runTurn(message) {
+    if (isSessionMismatch(message)) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: sessionMismatchError(message.sessionId)
+      });
+      return;
+    }
+    if (activeTurn && !activeTurn.finalized) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: "another turn is already running"
+      });
+      return;
+    }
+    activeTurn = {
+      sessionId,
+      turnId: message.turnId,
+      prompt: message.prompt,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now(),
+      interrupted: false,
+      stalled: false,
+      finalized: false,
+      summary: ""
+    };
+    const turn = activeTurn;
+    writeEvent({ type: "turn.started", sessionId: activeTurn.sessionId, turnId: activeTurn.turnId });
+    if (params.mockResponse !== void 0) {
+      if (mockResponseDelayMs > 0) {
+        await delay(mockResponseDelayMs);
+      }
+      if (activeTurn !== turn || turn.finalized) {
+        return;
+      }
+      display(params.mockResponse);
+      finalize("completed");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    if (params.startupError) {
+      finalize("failed", params.startupError);
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    try {
+      await ensureRuntime();
+    } catch (error) {
+      finalize("failed", error instanceof Error ? error.message : String(error));
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    const runtime = params.runtime;
+    if (runtime?.initialModel.unconfigured) {
+      finalize("failed", runtime.initialModel.warning || "No models are configured.");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    if (!controller || !agent) {
+      finalize("failed", "JSON events runtime was not initialized");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    const progressTimer = setInterval(() => {
+      const turn2 = activeTurn;
+      if (!turn2 || turn2.finalized) return;
+      if (Date.now() - turn2.lastActivityAt >= noProgressTimeoutMs) {
+        turn2.stalled = true;
+        agent?.abort();
+        finalize("stalled", "no_progress_timeout");
+      }
+    }, Math.max(1e3, Math.min(noProgressTimeoutMs, 1e4)));
+    progressTimer.unref?.();
+    try {
+      trace?.notePendingUserText(message.prompt);
+      trace?.noteDispatchStart({ mode: "json-events" });
+      await controller.prompt(message.prompt, { source: "json-events" });
+      trace?.noteDispatchSettled({ mode: "json-events" });
+      trace?.noteWaitForIdleStart({ mode: "json-events" });
+      await controller.waitForIdle();
+      trace?.noteWaitForIdleSettled({ mode: "json-events" });
+      if (!activeTurn?.finalized) {
+        const text = activeTurn?.summary.trim() || assistantTextFromAgent(agent);
+        if (!activeTurn?.summary && text) {
+          display(text);
+        }
+        finalize(activeTurn?.interrupted ? "cancelled" : "completed", activeTurn?.interrupted ? "user_interrupt" : void 0);
+      }
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error);
+      trace?.noteStalled(messageText, { mode: "json-events" });
+      if (!activeTurn?.finalized) {
+        finalize(activeTurn?.interrupted ? "cancelled" : "failed", activeTurn?.interrupted ? "user_interrupt" : messageText);
+      }
+    } finally {
+      clearInterval(progressTimer);
+      trace?.flush();
+      await runtime?.sessionManager.save();
+      if (activeTurn === turn) activeTurn = null;
+    }
+  }
+  async function interrupt(message) {
+    if (isSessionMismatch(message)) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId || "no-active-turn",
+        reason: sessionMismatchError(message.sessionId)
+      });
+      return;
+    }
+    if (!activeTurn || activeTurn.finalized) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId || "no-active-turn",
+        reason: message.reason || "no_active_turn"
+      });
+      return;
+    }
+    if (message.turnId && message.turnId !== activeTurn.turnId) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId,
+        reason: `turn mismatch: active turn is ${activeTurn.turnId}`
+      });
+      return;
+    }
+    activeTurn.interrupted = true;
+    agent?.abort();
+    if (params.mockResponse !== void 0) {
+      finalize("cancelled", message.reason || "user_interrupt");
+      activeTurn = null;
+    }
+  }
+  const input = readline.createInterface({ input: process.stdin });
+  let activeTurnPromise = null;
+  for await (const line of input) {
+    if (!line.trim()) continue;
+    const message = parseInput(line);
+    if (!message) {
+      writeEvent({ type: "turn.failed", sessionId, turnId: `invalid-${Date.now()}`, error: "invalid JSON events input" });
+      continue;
+    }
+    if (message.type === "shutdown") {
+      if (activeTurn && !activeTurn.finalized) {
+        activeTurn.interrupted = true;
+        agent?.abort();
+        finalize("cancelled", message.reason || "shutdown");
+      }
+      break;
+    }
+    if (message.type === "turn.interrupt") {
+      await interrupt(message);
+      continue;
+    }
+    const shouldTrackTurn = !activeTurn || activeTurn.finalized;
+    const turnPromise = runTurn(message).catch((error) => {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }).finally(() => {
+      if (activeTurnPromise === turnPromise) {
+        activeTurnPromise = null;
+      }
+    });
+    if (shouldTrackTurn) {
+      activeTurnPromise = turnPromise;
+    }
+  }
+  await activeTurnPromise;
+  disposeAgentSubscription?.();
+  disposeSemanticSubscription?.();
+  controller?.dispose();
+  await params.runtime?.sessionManager.save();
+  trace?.flush();
+}
+
 // src/cli.ts
 enableEarlyLogBuffer();
 var logError = (msg, err) => {
@@ -67567,6 +68099,7 @@ Config Files:
 Print Mode Options:
   --raw-output     Print assistant text only in non-interactive mode
   --json-output    Print structured JSON in non-interactive mode
+  --json-events    Run JSONL protocol mode over stdin/stdout
   --session-id     Reuse or create a specific session in non-interactive mode
   --extension-path Add an extra extension search directory (repeatable)
 `);
@@ -67649,12 +68182,55 @@ function parseRepeatedFlag(args, flag) {
   }
   return values;
 }
+async function runWithJsonEventsConsoleIsolation(fn) {
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  const originalDebug = console.debug;
+  const redirectToStderr = (...args) => console.error(...args);
+  console.log = redirectToStderr;
+  console.info = redirectToStderr;
+  console.debug = redirectToStderr;
+  try {
+    await fn();
+  } finally {
+    console.log = originalLog;
+    console.info = originalInfo;
+    console.debug = originalDebug;
+  }
+}
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");
   const jsonOutput = process.argv.includes("--json-output");
+  const jsonEvents = process.argv.includes("--json-events");
   const sessionIdFlagIndex = process.argv.indexOf("--session-id");
   const explicitSessionId = sessionIdFlagIndex >= 0 ? process.argv[sessionIdFlagIndex + 1] : void 0;
   const extensionPaths = parseRepeatedFlag(process.argv, "--extension-path");
+  if (jsonEvents) {
+    await runWithJsonEventsConsoleIsolation(async () => {
+      if (process.env.PIE_TEST_MOCK_RESPONSE !== void 0) {
+        await runJsonEventsMode({
+          explicitSessionId,
+          mockResponse: process.env.PIE_TEST_MOCK_RESPONSE
+        });
+        return;
+      }
+      let runtime2;
+      try {
+        runtime2 = await composeCliRuntime({ explicitSessionId, extensionPaths });
+      } catch (error) {
+        if (error instanceof CliMissingApiKeyError) {
+          await runJsonEventsMode({
+            explicitSessionId,
+            startupError: error.message
+          });
+          return;
+        }
+        throw error;
+      }
+      await runJsonEventsMode({ runtime: runtime2, explicitSessionId });
+    });
+    return;
+  }
   if (initialPrompt && process.env.PIE_TEST_MOCK_RESPONSE !== void 0) {
     const text = process.env.PIE_TEST_MOCK_RESPONSE;
     if (jsonOutput) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "1.0.13",
+	"version": "1.0.14",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {