@iinm/plain-agent 1.8.4 → 1.8.5

package/src/agentLoop.mjs

@@ -0,0 +1,419 @@
+/**
+ * @import { AgentEventEmitter } from "./agent"
+ * @import { CallModel, MessageContentText, MessageContentImage, MessageContentToolResult, PartialMessageContent, UserMessage, MessageContentToolUse } from "./model"
+ * @import { ToolDefinition, ToolUseApprover } from "./tool"
+ * @import { SubagentManager } from "./subagent.mjs"
+ * @import { StateManager } from "./agentState.mjs"
+ */
+
+import { styleText } from "node:util";
+import { compactContextToolName } from "./tools/compactContext.mjs";
+
+/**
+ * If compact_context was called successfully, discard the prior conversation
+ * (keeping only the system prompt) and append the tool result as a standard
+ * user message so the model can resume from the reloaded memory file.
+ * @param {StateManager} stateManager
+ * @param {MessageContentToolUse[]} toolUseParts
+ * @param {MessageContentToolResult[]} toolResults
+ * @returns {boolean} true if compact was applied
+ */
+function applyCompactContextIfCalled(stateManager, toolUseParts, toolResults) {
+  const compactToolUse = toolUseParts.find(
+    (t) => t.toolName === compactContextToolName,
+  );
+  if (!compactToolUse) return false;
+
+  const compactResult = toolResults.find(
+    (r) => r.toolUseId === compactToolUse.toolUseId,
+  );
+  if (!compactResult || compactResult.isError) return false;
+
+  const systemMessage = stateManager.getMessageAt(0);
+  if (!systemMessage) return false;
+
+  stateManager.setMessages([systemMessage]);
+  stateManager.appendMessages([
+    { role: "user", content: compactResult.content },
+  ]);
+  return true;
+}
+
+/**
+ * @typedef {Object} PauseSignal
+ * @property {() => boolean} isPaused - Returns true if auto-approve should be paused
+ * @property {() => void} reset - Resets the paused state
+ */
+
+/**
+ * @typedef {Object} AgentLoopConfig
+ * @property {CallModel} callModel - Function to call the language model
+ * @property {StateManager} stateManager - State manager for message handling
+ * @property {ToolDefinition[]} toolDefs - Tool definitions for the model
+ * @property {import("./toolExecutor.mjs").ToolExecutor} toolExecutor - Tool executor instance
+ * @property {AgentEventEmitter} agentEventEmitter - Event emitter for agent events
+ * @property {ToolUseApprover} toolUseApprover - Tool use approval checker
+ * @property {SubagentManager} subagentManager - Subagent manager instance
+ * @property {PauseSignal} pauseSignal - Signal to pause auto-approve after current tool completes
+ */
+
+/**
+ * @typedef {ReturnType<typeof createAgentLoop>} AgentLoop
+ */
+
+/**
+ * Create an agent loop handler
+ * @param {AgentLoopConfig} config
+ */
+export function createAgentLoop({
+  callModel,
+  stateManager,
+  toolDefs,
+  toolExecutor,
+  agentEventEmitter,
+  toolUseApprover,
+  subagentManager,
+  pauseSignal,
+}) {
+  const inputHandler = createInputHandler({
+    stateManager,
+    toolExecutor,
+    subagentManager,
+    toolUseApprover,
+  });
+
+  /**
+   * Handle user input and run the agent turn loop
+   * @param {(MessageContentText | MessageContentImage)[]} input - User input content
+   * @returns {Promise<void>}
+   */
+  async function handleUserInput(input) {
+    pauseSignal.reset();
+    toolUseApprover.resetApprovalCount();
+    await inputHandler.handle(input);
+    await runTurnLoop();
+    agentEventEmitter.emit("turnEnd");
+  }
+
+  /**
+   * Run the main agent turn loop
+   * @returns {Promise<void>}
+   */
+  async function runTurnLoop() {
+    let thinkingLoops = 0;
+    const maxThinkingLoops = 5;
+
+    while (true) {
+      // Check if auto-approve was paused by Ctrl-C during tool execution
+      if (pauseSignal.isPaused()) {
+        pauseSignal.reset();
+        break;
+      }
+
+      const modelOutput = await callModel({
+        messages: stateManager.getMessages(),
+        tools: toolDefs,
+        /**
+         * @param {PartialMessageContent} partialContent
+         */
+        onPartialMessageContent: (partialContent) => {
+          agentEventEmitter.emit("partialMessageContent", partialContent);
+        },
+      });
+
+      if (modelOutput instanceof Error) {
+        agentEventEmitter.emit("error", modelOutput);
+        break;
+      }
+
+      const { message: assistantMessage, providerTokenUsage } = modelOutput;
+      stateManager.appendMessages([assistantMessage]);
+      if (providerTokenUsage) {
+        agentEventEmitter.emit("providerTokenUsage", providerTokenUsage);
+      }
+
+      // Gemini may stop with "thinking" -> continue
+      const lastContent = assistantMessage.content.at(-1);
+      if (lastContent?.type === "thinking") {
+        thinkingLoops += 1;
+        if (thinkingLoops > maxThinkingLoops) {
+          break;
+        }
+
+        stateManager.appendMessages([
+          {
+            role: "user",
+            content: [{ type: "text", text: "System: Continue" }],
+          },
+        ]);
+        console.error(
+          styleText(
+            "yellow",
+            `\nModel is thinking. Sending "System: Continue" (Loop: ${thinkingLoops}/${maxThinkingLoops})`,
+          ),
+        );
+        continue;
+      }
+
+      const toolUseParts = assistantMessage.content.filter(
+        (part) => part.type === "tool_use",
+      );
+
+      // No tool use -> turn end
+      if (toolUseParts.length === 0) {
+        break;
+      }
+
+      const validation = toolExecutor.validateBatch(toolUseParts);
+      if (!validation.isValid) {
+        stateManager.appendMessages([
+          {
+            role: "user",
+            content: validation.toolResults,
+          },
+        ]);
+        if (validation.errorMessage) {
+          console.error(styleText("yellow", validation.errorMessage));
+        }
+        continue;
+      }
+
+      // Approve tool use
+      const decisions = toolUseParts.map(toolUseApprover.isAllowedToolUse);
+
+      const hasDeniedToolUse = decisions.some((d) => d.action === "deny");
+      if (hasDeniedToolUse) {
+        /** @type {MessageContentToolResult[]} */
+        const toolResults = toolUseParts.map((toolUse, index) => {
+          const decision = decisions[index];
+          const rejectionMessage =
+            decision.action === "deny"
+              ? `Tool call rejected. ${decision.reason || ""}`.trim()
+              : "Tool call rejected due to other denied tool calls";
+
+          return {
+            type: "tool_result",
+            toolUseId: toolUse.toolUseId,
+            toolName: toolUse.toolName,
+            content: [{ type: "text", text: rejectionMessage }],
+            isError: true,
+          };
+        });
+        stateManager.appendMessages([{ role: "user", content: toolResults }]);
+        continue;
+      }
+
+      const isAllToolUseApproved = decisions.every((d) => d.action === "allow");
+      if (!isAllToolUseApproved) {
+        agentEventEmitter.emit("toolUseRequest");
+        break;
+      }
+
+      const executionResult = await toolExecutor.executeBatch(toolUseParts);
+
+      if (!executionResult.success) {
+        stateManager.appendMessages([
+          {
+            role: "user",
+            content: executionResult.errors,
+          },
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: executionResult.errorMessage,
+              },
+            ],
+          },
+        ]);
+        console.error(styleText("yellow", executionResult.errorMessage));
+        continue;
+      }
+
+      const toolResults = executionResult.results;
+
+      if (
+        applyCompactContextIfCalled(stateManager, toolUseParts, toolResults)
+      ) {
+        continue;
+      }
+
+      const result = subagentManager.processToolResults(
+        toolUseParts,
+        toolResults,
+        stateManager.getMessages(),
+      );
+      stateManager.setMessages(result.messages);
+      if (result.newMessage) {
+        stateManager.appendMessages([result.newMessage]);
+      } else {
+        stateManager.appendMessages([{ role: "user", content: toolResults }]);
+      }
+    }
+  }
+
+  return {
+    handleUserInput,
+  };
+}
+
+/**
+ * @typedef {Object} InputHandlerContext
+ * @property {StateManager} stateManager
+ * @property {import("./toolExecutor.mjs").ToolExecutor} toolExecutor
+ * @property {import("./subagent.mjs").SubagentManager} subagentManager
+ * @property {import("./tool.d.ts").ToolUseApprover} toolUseApprover
+ */
+
+/**
+ * @typedef {ReturnType<typeof createInputHandler>} InputHandler
+ */
+
+/**
+ * Create an input handler.
+ *
+ * @param {InputHandlerContext} context
+ */
+export function createInputHandler(context) {
+  const { stateManager, toolExecutor, subagentManager, toolUseApprover } =
+    context;
+
+  /**
+   * Determine input type based on current state and input.
+   * @param {UserMessage["content"]} input
+   * @returns {'toolApproval' | 'resume' | 'text'}
+   */
+  function determineInputType(input) {
+    const lastMessage = stateManager.getMessageAt(-1);
+
+    // Check if there's a pending tool call
+    if (lastMessage?.content.some((part) => part.type === "tool_use")) {
+      return "toolApproval";
+    }
+
+    if (
+      input.length === 1 &&
+      input[0].type === "text" &&
+      input[0].text.toLowerCase() === "/resume"
+    ) {
+      return "resume";
+    }
+
+    return "text";
+  }
+
+  /**
+   * Handle tool approval/rejection input.
+   * @param {UserMessage["content"]} input
+   */
+  async function handleToolApproval(input) {
+    const lastMessage = stateManager.getMessageAt(-1);
+    if (!lastMessage) return;
+
+    /** @type {MessageContentToolUse[]} */
+    const toolUseParts = lastMessage.content.filter(
+      (part) => part.type === "tool_use",
+    );
+
+    const isApproval =
+      input.length === 1 &&
+      input[0].type === "text" &&
+      input[0].text.toLocaleLowerCase().match(/^(yes|y|ｙ)$/i);
+
+    if (isApproval) {
+      if (
+        /** @type {MessageContentText} */ (input[0]).text.match(/^(YES|Y)$/)
+      ) {
+        for (const toolUse of toolUseParts) {
+          toolUseApprover.allowToolUse(toolUse);
+        }
+      }
+
+      const executionResult = await toolExecutor.executeBatch(toolUseParts);
+      if (!executionResult.success) {
+        stateManager.appendMessages([
+          { role: "user", content: executionResult.errors },
+        ]);
+        return;
+      }
+
+      const toolResults = executionResult.results;
+
+      if (
+        applyCompactContextIfCalled(stateManager, toolUseParts, toolResults)
+      ) {
+        return;
+      }
+
+      const result = subagentManager.processToolResults(
+        toolUseParts,
+        toolResults,
+        stateManager.getMessages(),
+      );
+      stateManager.setMessages(result.messages);
+
+      if (result.newMessage) {
+        stateManager.appendMessages([result.newMessage]);
+      } else {
+        stateManager.appendMessages([{ role: "user", content: toolResults }]);
+      }
+    } else {
+      // Rejected
+      /** @type {MessageContentToolResult[]} */
+      const toolResults = toolUseParts.map((toolUse) => ({
+        type: "tool_result",
+        toolUseId: toolUse.toolUseId,
+        toolName: toolUse.toolName,
+        content: [{ type: "text", text: "Tool call rejected" }],
+        isError: true,
+      }));
+
+      stateManager.appendMessages([
+        { role: "user", content: toolResults },
+        {
+          role: "user",
+          content: input,
+        },
+      ]);
+    }
+  }
+
+  async function handleResume() {
+    // Resume the conversation stopped by unexpected error, etc.
+    // No state changes needed
+  }
+
+  /**
+   * @param {UserMessage["content"]} input
+   */
+  async function handleText(input) {
+    stateManager.appendMessages([
+      {
+        role: "user",
+        content: input,
+      },
+    ]);
+  }
+
+  return {
+    /**
+     * @param {UserMessage["content"]} input
+     */
+    async handle(input) {
+      const inputType = determineInputType(input);
+
+      switch (inputType) {
+        case "toolApproval":
+          await handleToolApproval(input);
+          break;
+        case "resume":
+          await handleResume();
+          break;
+        case "text":
+          await handleText(input);
+          break;
+      }
+    },
+  };
+}

package/src/agentState.mjs

@@ -0,0 +1,41 @@
+/**
+ * @import { Message } from "./model"
+ */
+
+/**
+ * @typedef {ReturnType<typeof createStateManager>} StateManager
+ */
+
+/**
+ * @typedef {Object} StateEventHandlers
+ * @property {(messages: Message[]) => void} onMessagesAppended
+ */
+
+/**
+ * Creates a state manager for message handling.
+ * @param {Message[]} initialMessages
+ * @param {StateEventHandlers} handlers
+ */
+export function createStateManager(initialMessages, handlers) {
+  /** @type {Message[]} */
+  let messages = [...initialMessages];
+
+  return {
+    /** Get all messages (immutable copy) */
+    getMessages: () => [...messages],
+
+    /** Get message at specific index (supports -1 for last) */
+    getMessageAt: /** @param {number} index */ (index) => messages.at(index),
+
+    /** Append messages */
+    appendMessages: /** @param {Message[]} newMessages */ (newMessages) => {
+      messages = [...messages, ...newMessages];
+      handlers.onMessagesAppended(newMessages);
+    },
+
+    /** Replace all messages */
+    setMessages: /** @param {Message[]} newMessages */ (newMessages) => {
+      messages = [...newMessages];
+    },
+  };
+}

package/src/claudeCodePlugin.mjs

@@ -0,0 +1,164 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadAppConfig } from "./config.mjs";
+import { CLAUDE_CODE_PLUGIN_DIR } from "./env.mjs";
+
+/**
+ * @typedef {Object} ClaudeCodePluginRepo
+ * @property {string} source
+ * @property {Array<{name: string, path: string, only?: string}>} plugins
+ */
+
+/**
+ * @typedef {Object} ClaudeCodePlugin
+ * @property {string} name
+ * @property {string} path
+ * @property {RegExp} [only]
+ */
+
+/**
+ * Resolve plugin paths from hierarchical config structure.
+ * Converts {source, plugins} to flat {name, path, only} with full paths.
+ * @param {ClaudeCodePluginRepo[]} repos
+ * @returns {ClaudeCodePlugin[]}
+ */
+export function resolvePluginPaths(repos) {
+  if (!repos) return [];
+
+  /** @type {ClaudeCodePlugin[]} */
+  const result = [];
+
+  for (const repo of repos) {
+    const ownerRepo = extractOwnerRepo(repo.source);
+    if (!ownerRepo) {
+      console.warn(`Invalid source URL: ${repo.source}`);
+      continue;
+    }
+
+    for (const plugin of repo.plugins) {
+      // Compile only pattern to RegExp
+      let only;
+      if (plugin.only) {
+        try {
+          only = new RegExp(plugin.only);
+        } catch (err) {
+          console.warn(
+            `Invalid regex pattern "${plugin.only}" for plugin "${plugin.name}":`,
+            err instanceof Error ? err.message : String(err),
+          );
+        }
+      }
+
+      result.push({
+        name: plugin.name,
+        path: path.join(CLAUDE_CODE_PLUGIN_DIR, ownerRepo, plugin.path),
+        only,
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Install Claude Code plugins by cloning repositories.
+ */
+export async function installClaudeCodePlugins() {
+  const { appConfig } = await loadAppConfig({ skipTrustCheck: true });
+  const repos = appConfig.claudeCodePlugins ?? [];
+
+  if (repos.length === 0) {
+    console.log("No plugins configured.");
+    return;
+  }
+
+  let installed = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  // Track paths for summary
+  /** @type {string[]} */
+  const installedPaths = [];
+  /** @type {string[]} */
+  const skippedPaths = [];
+
+  // Ensure plugin directory exists
+  await fs.mkdir(CLAUDE_CODE_PLUGIN_DIR, { recursive: true });
+
+  for (const repo of repos) {
+    const ownerRepo = extractOwnerRepo(repo.source);
+    if (!ownerRepo) {
+      console.error(`❌ Invalid source URL: ${repo.source}`);
+      failed++;
+      continue;
+    }
+
+    const destPath = path.join(CLAUDE_CODE_PLUGIN_DIR, ownerRepo);
+
+    // Check if already exists
+    const exists = await fs
+      .access(destPath)
+      .then(() => true)
+      .catch(() => false);
+    if (exists) {
+      console.log(`⏭️ Skipping ${repo.source} → ${destPath}: already installed`);
+      skippedPaths.push(destPath);
+      skipped++;
+      continue;
+    }
+
+    // Clone the repository
+    console.log(`📥 Installing ${repo.source}...`);
+    try {
+      await new Promise((resolve, reject) => {
+        execFile(
+          "git",
+          ["clone", "--depth", "1", repo.source, destPath],
+          (err) => {
+            if (err) reject(err);
+            else resolve(undefined);
+          },
+        );
+      });
+      console.log(`✅ Installed to ${destPath}`);
+      installedPaths.push(destPath);
+      installed++;
+    } catch (error) {
+      console.error(
+        `❌ Failed to install: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      failed++;
+    }
+  }
+
+  console.log(
+    `\n📊 Summary: ${installed} installed, ${skipped} skipped, ${failed} failed`,
+  );
+
+  if (installedPaths.length > 0) {
+    console.log("\nInstalled:");
+    for (const p of installedPaths) {
+      console.log(`  • ${p}`);
+    }
+  }
+
+  if (skippedPaths.length > 0) {
+    console.log("\nSkipped:");
+    for (const p of skippedPaths) {
+      console.log(`  • ${p}`);
+    }
+  }
+}
+
+/**
+ * Extract owner/repo from source URL.
+ * @param {string} source
+ * @returns {string|null}
+ */
+function extractOwnerRepo(source) {
+  // Handle: https://github.com/owner/repo
+  // Handle: git@github.com:owner/repo.git
+  const match = source.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+  return match ? match[1] : null;
+}