@kalenkevich/agent_007 0.0.1

package/src/agent/cli_agent/cli_agent.ts

@@ -0,0 +1,418 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import type { Agent } from "../agent.js";
+import type { LlmModel } from "../../model/model.js";
+import type { Skill } from "../../skills/skill.js";
+import type { Tool } from "../../tools/tool.js";
+import {
+  type AgentEvent,
+  AgentEventType,
+  AgentEndReason,
+  type ToolCallEvent,
+  isUserInputResponseEvent,
+} from "../agent_event.js";
+import type { Content } from "../../content.js";
+import {
+  type UserInput,
+  isUserCommand,
+  toContentParts,
+  UserCommandType,
+} from "../../user_input.js";
+import type { ThinkingConfig } from "../../model/request.js";
+import {
+  getContentFromAgentEvent,
+  llmResponseToAgentEvents,
+} from "../agent_event_utils.js";
+import { logger } from "../../logger.js";
+import { CLI_AGENT_SYSTEM_PROMPT } from "./system_prompt.js";
+import { BUILD_IN_TOOLS } from "../../tools/build_in/index.js";
+import { PlannerAgent } from "../planner_agent/planner_agent.js";
+import {
+  type ToolCallPolicy,
+  DEFAULT_POLICY,
+} from "../../tools/tool_call_policy.js";
+import type { CompactionConfig } from "../../config/config.js";
+import { BasicRequestProcessor } from "../request_processor/basic_request_processor.js";
+import { CompactionProcessor } from "../request_processor/compaction_processor.js";
+import type { AgentState } from "../request_processor/request_processor.js";
+
+export interface CliAgentOptions {
+  model: LlmModel;
+  history?: AgentEvent[];
+  skills?: Skill[];
+  thinkingConfig?: ThinkingConfig;
+  compactionConfig?: CompactionConfig;
+  toolPolicies?: Record<string, ToolCallPolicy>;
+  tools?: Tool[];
+  instructions?: string;
+}
+
+export class CliAgent implements Agent {
+  readonly id = "cli_agent";
+  readonly name = "Agent 007";
+  readonly description = "Agent 007";
+  readonly instructions: string;
+  readonly tools: Tool[];
+  readonly skills?: Skill[];
+
+  readonly model: LlmModel;
+  private streamId?: string;
+  private history: AgentEvent[] = [];
+  private historyContent: Content[] = [];
+  private thinkingConfig?: ThinkingConfig;
+  private toolPolicies: Record<string, ToolCallPolicy>;
+  private compactionConfig?: CompactionConfig;
+  private abortController?: AbortController;
+
+  constructor(options: CliAgentOptions) {
+    this.model = options.model;
+    this.thinkingConfig = options.thinkingConfig;
+    this.skills = options.skills;
+    this.history = options.history || [];
+    this.historyContent = this.history
+      .map((c) => getContentFromAgentEvent(c))
+      .filter(Boolean) as Content[];
+    this.toolPolicies = options.toolPolicies || {};
+    this.tools = options.tools || BUILD_IN_TOOLS;
+    this.compactionConfig = options.compactionConfig;
+    this.instructions = options.instructions || CLI_AGENT_SYSTEM_PROMPT;
+  }
+
+  async *run(userInput: UserInput): AsyncGenerator<AgentEvent, void, unknown> {
+    for await (const agentEvent of this.runInternal(userInput)) {
+      this.history.push(agentEvent);
+      const content = getContentFromAgentEvent(agentEvent);
+      if (content) {
+        this.historyContent.push(content);
+      }
+
+      yield agentEvent;
+    }
+  }
+
+  private async *runInternal(
+    userInput: UserInput,
+  ): AsyncGenerator<AgentEvent, void, unknown> {
+    if (isUserCommand(userInput)) {
+      if (userInput.command === UserCommandType.PLAN) {
+        const planner = new PlannerAgent({
+          model: this.model,
+          tools: this.tools,
+          skills: this.skills,
+        });
+        yield* planner.run(userInput.task);
+      }
+      return;
+    }
+
+    logger.debug("[CliAgent] runInternal started");
+
+    const lastEvent = this.history[this.history.length - 1];
+    let skipInitialEvents = false;
+
+    if (lastEvent && lastEvent.type === AgentEventType.USER_INPUT_REQUEST) {
+      logger.debug("[CliAgent] Resuming from USER_INPUT_REQUEST");
+      this.streamId = lastEvent.streamId;
+      skipInitialEvents = true;
+
+      const requestId = lastEvent.requestId;
+      if ((lastEvent.requestSchema as any)?.type === "plan_approval") {
+        const isAccepted =
+          isUserInputResponseEvent(userInput) && userInput.action === "accept";
+
+        if (isAccepted) {
+          const planFilePath = (lastEvent.requestSchema as any)
+            .planFilePath as string;
+          try {
+            const planContent = await fs.readFile(planFilePath, "utf-8");
+            yield this.createEvent(AgentEventType.MESSAGE, {
+              role: "user",
+              parts: [
+                {
+                  type: "text",
+                  text: `Plan approved. Please execute the following plan:\n\n${planContent}`,
+                },
+              ],
+            });
+          } catch (error: any) {
+            logger.error(`Failed to read plan file: ${error.message}`);
+            yield this.createEvent(AgentEventType.MESSAGE, {
+              role: "user",
+              parts: [
+                {
+                  type: "text",
+                  text: `Plan approved, but failed to read plan file: ${error.message}. Please proceed if you know the plan.`,
+                },
+              ],
+            });
+          }
+        } else {
+          yield this.createEvent(AgentEventType.MESSAGE, {
+            role: "user",
+            parts: [{ type: "text", text: "Plan declined." }],
+          });
+        }
+      } else {
+        const toolCall = this.history.find(
+          (e) =>
+            e.type === AgentEventType.TOOL_CALL && e.requestId === requestId,
+        ) as ToolCallEvent;
+
+        if (toolCall) {
+          const isAccepted =
+            isUserInputResponseEvent(userInput as any) &&
+            (userInput as any).action === "accept";
+
+          if (isAccepted) {
+            const tool = this.tools.find((t) => t.name === toolCall.name);
+            if (tool) {
+              try {
+                logger.debug(
+                  `[CliAgent] Executing tool ${toolCall.name} after confirmation`,
+                );
+                const result = await tool.execute(toolCall.args);
+                yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+                  role: "user",
+                  requestId: toolCall.requestId,
+                  name: toolCall.name,
+                  result: result as Record<string, unknown> | string,
+                  parts: [
+                    {
+                      type: "function_response",
+                      id: toolCall.requestId,
+                      name: toolCall.name,
+                      response:
+                        typeof result === "object"
+                          ? (result as Record<string, unknown>)
+                          : { result },
+                    },
+                  ],
+                });
+              } catch (error: any) {
+                logger.error(
+                  `[CliAgent] Tool execution failed: ${error.message}`,
+                );
+                yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+                  role: "user",
+                  requestId: toolCall.requestId,
+                  name: toolCall.name,
+                  error: error.message,
+                  result: {},
+                  parts: [
+                    {
+                      type: "function_response",
+                      id: toolCall.requestId,
+                      name: toolCall.name,
+                      response: { error: error.message },
+                    },
+                  ],
+                });
+              }
+            }
+          } else {
+            logger.debug(
+              `[CliAgent] Tool ${toolCall.name} execution declined by user`,
+            );
+            yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+              role: "user",
+              requestId: toolCall.requestId,
+              name: toolCall.name,
+              error: "User declined tool execution",
+              result: {},
+              parts: [
+                {
+                  type: "function_response",
+                  id: toolCall.requestId,
+                  name: toolCall.name,
+                  response: { error: "User declined tool execution" },
+                },
+              ],
+            });
+          }
+        } else {
+          if (isUserInputResponseEvent(userInput)) {
+            yield this.createEvent(userInput.type, userInput);
+          }
+        }
+      }
+    }
+
+    if (!skipInitialEvents) {
+      const userContent = toContentParts(userInput as any);
+      this.abortController = new AbortController();
+      this.streamId = randomUUID();
+
+      yield this.createEvent(AgentEventType.START);
+      yield this.createEvent(AgentEventType.MESSAGE, {
+        role: "user",
+        parts: userContent,
+      });
+    }
+
+    let continueTurn = true;
+
+    while (continueTurn) {
+      const basicProcessor = new BasicRequestProcessor({
+        agentName: this.name,
+        description: this.description,
+        instructions: this.instructions,
+        tools: this.tools,
+        skills: this.skills,
+        thinkingConfig: this.thinkingConfig,
+      });
+
+      const compactionProcessor = new CompactionProcessor({
+        model: this.model,
+        compactionConfig: this.compactionConfig,
+        requestBuilderOptions: {
+          agentName: this.name,
+          description: this.description,
+          instructions: this.instructions,
+          tools: this.tools,
+          skills: this.skills,
+          thinkingConfig: this.thinkingConfig,
+        },
+        streamId: this.streamId!,
+      });
+
+      let state: AgentState = {
+        historyContent: this.historyContent,
+        events: [],
+      };
+
+      state = await basicProcessor.process(state);
+      state = await compactionProcessor.process(state);
+
+      this.historyContent = state.historyContent;
+
+      for (const event of state.events) {
+        yield event;
+      }
+
+      const llmRequest = state.llmRequest;
+      if (!llmRequest) {
+        throw new Error("LlmRequest is missing after processors");
+      }
+
+      logger.debug("[CliAgent] calling model.run");
+
+      const toolCalls: ToolCallEvent[] = [];
+
+      for await (const modelResponse of this.model.run(llmRequest, {
+        stream: true,
+        abortSignal: this.abortController?.signal,
+      })) {
+        for (const agentEvent of llmResponseToAgentEvents(modelResponse)) {
+          logger.debug("[CliAgent] yielding event:", agentEvent.type);
+          yield this.createEvent(agentEvent.type!, agentEvent);
+
+          if (
+            agentEvent.type === AgentEventType.TOOL_CALL &&
+            !agentEvent.partial
+          ) {
+            toolCalls.push(agentEvent as ToolCallEvent);
+          }
+        }
+      }
+
+      if (toolCalls.length === 0) {
+        continueTurn = false;
+        break;
+      }
+
+      for (const toolCall of toolCalls) {
+        const tool = this.tools.find((t) => t.name === toolCall.name);
+        if (!tool) {
+          logger.error(`[CliAgent] Tool not found: ${toolCall.name}`);
+          yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+            role: "user",
+            requestId: toolCall.requestId,
+            name: toolCall.name,
+            error: `Tool ${toolCall.name} not found`,
+            result: {},
+          });
+          continue;
+        }
+
+        const policy = this.toolPolicies[toolCall.name] || DEFAULT_POLICY;
+        if (policy.confirmationRequired) {
+          logger.debug(
+            `[CliAgent] Tool ${toolCall.name} requires confirmation`,
+          );
+          yield this.createEvent(AgentEventType.USER_INPUT_REQUEST, {
+            role: "agent",
+            requestId: toolCall.requestId,
+            message: `Do you want to allow execution of tool ${toolCall.name}?`,
+          });
+          return;
+        }
+
+        try {
+          logger.debug(`[CliAgent] Executing tool ${toolCall.name}`);
+          const result = await tool.execute(toolCall.args);
+          yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+            role: "user",
+            requestId: toolCall.requestId,
+            name: toolCall.name,
+            result: result as Record<string, unknown> | string,
+            parts: [
+              {
+                type: "function_response",
+                id: toolCall.requestId,
+                name: toolCall.name,
+                response:
+                  typeof result === "object"
+                    ? (result as Record<string, unknown>)
+                    : { result },
+              },
+            ],
+          });
+        } catch (error: any) {
+          logger.error(`[CliAgent] Tool execution failed: ${error.message}`);
+          yield this.createEvent(AgentEventType.TOOL_RESPONSE, {
+            role: "user",
+            requestId: toolCall.requestId,
+            name: toolCall.name,
+            error: error.message,
+            result: {},
+            parts: [
+              {
+                type: "function_response",
+                id: toolCall.requestId,
+                name: toolCall.name,
+                response: { error: error.message },
+              },
+            ],
+          });
+        }
+      }
+    }
+
+    yield this.createEvent(AgentEventType.END, {
+      role: "agent",
+      type: AgentEventType.END,
+      reason: AgentEndReason.COMPLETED,
+    });
+  }
+
+  private createEvent(
+    type: AgentEventType,
+    data: Partial<AgentEvent> = {},
+  ): AgentEvent {
+    return {
+      type,
+      id: randomUUID(),
+      streamId: this.streamId!,
+      timestamp: new Date().toISOString(),
+      ...data,
+    } as AgentEvent;
+  }
+
+  getHistory(): AgentEvent[] {
+    return [...this.history];
+  }
+
+  async abort(): Promise<void> {
+    this.abortController?.abort();
+  }
+}

package/src/agent/cli_agent/system_prompt.ts

@@ -0,0 +1,57 @@
+export const CLI_AGENT_SYSTEM_PROMPT = `
+You are Agent 007, an advanced AI coding assistant specializing in software engineering tasks. Your primary goal is to help users safely and effectively develop, debug, and maintain codebases.
+
+## Core Mandates
+
+### Security & System Integrity
+- **Credential Protection:** Never log, print, or commit secrets, API keys, or sensitive credentials. Rigorously protect \`.env\` files, \`.git\`, and system configuration folders.
+- **Source Control:** Do not stage or commit changes unless specifically requested by the user.
+
+### Context Efficiency
+Be strategic in your use of the available tools to minimize unnecessary context usage while still providing the best answer that you can.
+- **Minimize Turns:** Combine turns whenever possible by utilizing parallel searching and reading.
+- **Search First:** Prefer using search tools (e.g., grep, glob) to identify points of interest instead of reading lots of files individually.
+- **Conservative Limits:** Provide conservative limits and scopes to tools to reduce the impact on context, as long as it doesn't result in extra turns to recover missing data.
+
+### Conventions & Style
+- **Workspace Precedence:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting).
+- **Surgical Updates:** Analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context.
+
+### Technical Integrity & Quality
+- **No Hacks:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system, or employing "hidden" logic unless explicitly instructed. Use explicit and idiomatic language features.
+- **Library Verification:** NEVER assume a library/framework is available. Verify its established usage within the project (e.g., check \`package.json\`, \`Cargo.toml\`) before employing it.
+- **Lifecycle Responsibility:** You are responsible for the entire lifecycle: implementation, testing, and validation.
+- **Testing Mandate:** ALWAYS search for and update related tests after making a code change. You must add a new test case to the existing test file or create a new one to verify your changes.
+- **Bug Reproduction:** For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix.
+
+### Expertise & Intent Alignment
+- **Directives vs Inquiries:** Distinguish between **Directives** (unambiguous requests for action) and **Inquiries** (requests for analysis, advice, or observations).
+- **Default to Inquiry:** Assume all requests are Inquiries unless they contain an explicit instruction to perform a task.
+- **Scope Limitation:** For Inquiries, your scope is strictly limited to research and analysis. Propose solutions but DO NOT modify files until a corresponding Directive is issued.
+- **Autonomy:** For Directives, work autonomously. Only seek user intervention if you have exhausted all possible routes or if a proposed solution diverges significantly from the established architecture.
+
+## Development Lifecycle
+
+Operate using a **Research -> Strategy -> Execution** lifecycle. For the Execution phase, resolve each sub-task through an iterative **Plan -> Act -> Validate** cycle.
+
+1. **Research:** Systematically map the codebase and validate assumptions. Use search tools extensively to understand file structures and conventions. Prioritize empirical reproduction of reported issues.
+2. **Strategy:** Formulate a grounded plan based on your research. Share a concise summary of your strategy with the user before proceeding to execution.
+3. **Execution:** For each sub-task:
+   - **Plan:** Define the specific implementation approach and the testing strategy to verify the change.
+   - **Act:** Apply targeted, surgical changes. Ensure changes are idiomatically complete and follow all workspace standards.
+   - **Validate:** Run tests and workspace standards to confirm the success of the specific change and ensure no regressions were introduced. Validation is the only path to finality.
+
+## Operational Guidelines
+
+### Tone and Style
+- **Role:** A senior software engineer and collaborative peer programmer.
+- **High-Signal Output:** Focus exclusively on **intent** and **technical rationale**. Avoid conversational filler, apologies, and mechanical tool-use narration.
+- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment. Aim for minimal text output per response whenever practical.
+- **Formatting:** Use GitHub-flavored Markdown.
+
+### Tool Usage
+- **Parallelism:** Tools execute in parallel by default. Execute multiple independent tool calls in parallel when feasible (e.g., searching or reading different files).
+- **Sequencing:** If a tool depends on the output of a previous tool in the same turn, you MUST ensure sequential execution (e.g., setting specific flags if the system supports it).
+- **File Collisions:** Do NOT make multiple calls to edit tools for the SAME file in a single turn to prevent race conditions.
+- **Explain Critical Commands:** Before executing commands that modify the file system or system state, provide a brief explanation of the command's purpose and potential impact.
+`;

package/src/agent/planner_agent/planner_agent.ts

@@ -0,0 +1,136 @@
+import { randomUUID } from "node:crypto";
+import type { Agent } from "../agent.js";
+import type { LlmModel } from "../../model/model.js";
+import type { Tool } from "../../tools/tool.js";
+import type { Skill } from "../../skills/skill.js";
+import { type AgentEvent, AgentEventType } from "../agent_event.js";
+import { type UserInput } from "../../user_input.js";
+import { buildLlmRequest } from "../../model/request_builder_utils.js";
+import { llmResponseToAgentEvents } from "../agent_event_utils.js";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface PlannerAgentOptions {
+  model: LlmModel;
+  tools?: Tool[];
+  skills?: Skill[];
+}
+
+export class PlannerAgent implements Agent {
+  readonly id = "planner_agent";
+  readonly name = "Planner Agent";
+  readonly description = "Generates plans for tasks.";
+  readonly instructions =
+    "You are a planning assistant. Your job is to create a plan for the given task.";
+  readonly model: LlmModel;
+  readonly tools?: Tool[];
+  readonly skills?: Skill[];
+
+  private streamId?: string;
+  private history: AgentEvent[] = [];
+  private abortController?: AbortController;
+
+  constructor(options: PlannerAgentOptions) {
+    this.model = options.model;
+    this.tools = options.tools;
+    this.skills = options.skills;
+  }
+
+  async *run(userInput: UserInput): AsyncGenerator<AgentEvent, void, unknown> {
+    this.abortController = new AbortController();
+    this.streamId = randomUUID();
+
+    yield this.createEvent(AgentEventType.START);
+
+    const task =
+      typeof userInput === "string" ? userInput : JSON.stringify(userInput);
+
+    const planningPrompt = `Generate a plan for the following task: "${task}".
+The plan should be in free-form markdown.
+Respond ONLY with the plan.`;
+
+    const llmRequest = buildLlmRequest({
+      agentName: this.name,
+      content: {
+        role: "user",
+        parts: [{ type: "text", text: planningPrompt }],
+      },
+      historyContent: [],
+      tools: this.tools || [],
+      skills: this.skills,
+      description: this.description,
+      instructions: this.instructions,
+    });
+
+    let planContent = "";
+    for await (const modelResponse of this.model.run(llmRequest, {
+      stream: true,
+      abortSignal: this.abortController?.signal,
+    })) {
+      for (const agentEvent of llmResponseToAgentEvents(modelResponse)) {
+        yield this.createEvent(agentEvent.type!, agentEvent);
+        if (agentEvent.type === AgentEventType.MESSAGE && agentEvent.parts) {
+          for (const part of agentEvent.parts) {
+            if ("text" in part && part.text) {
+              planContent += part.text;
+            }
+          }
+        }
+      }
+    }
+
+    const requestId = randomUUID();
+    const tempFilePath = path.join(os.tmpdir(), `plan_${requestId}.md`);
+
+    try {
+      await fs.writeFile(tempFilePath, planContent, "utf-8");
+      yield this.createEvent(AgentEventType.MESSAGE, {
+        role: "agent",
+        parts: [{ type: "text", text: `\nPlan written to ${tempFilePath}` }],
+      });
+    } catch (error: any) {
+      yield this.createEvent(AgentEventType.MESSAGE, {
+        role: "agent",
+        parts: [
+          {
+            type: "text",
+            text: `\nFailed to write plan to ${tempFilePath}: ${error.message}`,
+          },
+        ],
+      });
+    }
+
+    yield this.createEvent(AgentEventType.USER_INPUT_REQUEST, {
+      role: "agent",
+      requestId,
+      message: "Do you approve this plan?",
+      requestSchema: { type: "plan_approval", planFilePath: tempFilePath },
+    });
+
+    return;
+  }
+
+  private createEvent(
+    type: AgentEventType,
+    data: Partial<AgentEvent> = {},
+  ): AgentEvent {
+    const event = {
+      type,
+      id: randomUUID(),
+      streamId: this.streamId!,
+      timestamp: new Date().toISOString(),
+      ...data,
+    } as AgentEvent;
+    this.history.push(event);
+    return event;
+  }
+
+  getHistory(): AgentEvent[] {
+    return [...this.history];
+  }
+
+  async abort(): Promise<void> {
+    this.abortController?.abort();
+  }
+}

package/src/agent/request_processor/basic_request_processor.ts

@@ -0,0 +1,46 @@
+import type {
+  RequestProcessor,
+  AgentState,
+} from "./request_processor.js";
+import { buildLlmRequest } from "../../model/request_builder_utils.js";
+import type { Tool } from "../../tools/tool.js";
+import type { Skill } from "../../skills/skill.js";
+import type { ThinkingConfig } from "../../model/request.js";
+
+export interface BasicRequestProcessorOptions {
+  agentName: string;
+  description: string;
+  instructions: string;
+  tools: Tool[];
+  skills?: Skill[];
+  thinkingConfig?: ThinkingConfig;
+}
+
+export class BasicRequestProcessor implements RequestProcessor {
+  constructor(private options: BasicRequestProcessorOptions) {}
+
+  async process(state: AgentState): Promise<AgentState> {
+    if (state.historyContent.length === 0) {
+      return state;
+    }
+
+    const lastContent = state.historyContent[state.historyContent.length - 1];
+    const historyForRequest = state.historyContent.slice(0, -1);
+
+    const llmRequest = buildLlmRequest({
+      agentName: this.options.agentName,
+      content: lastContent,
+      historyContent: historyForRequest,
+      tools: this.options.tools,
+      skills: this.options.skills,
+      description: this.options.description,
+      instructions: this.options.instructions,
+      thinkingConfig: this.options.thinkingConfig,
+    });
+
+    return {
+      ...state,
+      llmRequest,
+    };
+  }
+}