@kalenkevich/agent_007 0.0.1

package/src/agent/request_processor/compaction_processor.ts

@@ -0,0 +1,164 @@
+import type { RequestProcessor, AgentState } from "./request_processor.js";
+import type { LlmModel } from "../../model/model.js";
+import type { CompactionConfig } from "../../config/config.js";
+import type { BasicRequestProcessorOptions } from "./basic_request_processor.js";
+import { buildLlmRequest } from "../../model/request_builder_utils.js";
+import { logger } from "../../logger.js";
+import {
+  AgentEventType,
+  type AgentEvent,
+  type CompactionEvent,
+} from "../agent_event.js";
+import { randomUUID } from "node:crypto";
+import { UtilLlm } from "../../model/util_llm.js";
+import type { Content } from "../../content.js";
+
+export interface CompactionProcessorOptions {
+  model: LlmModel;
+  compactionConfig?: CompactionConfig;
+  requestBuilderOptions: BasicRequestProcessorOptions;
+  streamId: string;
+}
+
+export class CompactionProcessor implements RequestProcessor {
+  constructor(private options: CompactionProcessorOptions) {}
+
+  async process(state: AgentState): Promise<AgentState> {
+    const { compactionConfig, model, streamId } = this.options;
+
+    if (!compactionConfig?.enabled || !state.llmRequest) {
+      return state;
+    }
+
+    try {
+      const tokenCount = await model.countTokens(state.llmRequest);
+      logger.debug(`[CompactionProcessor] Current token count: ${tokenCount}`);
+
+      const maxTokens = compactionConfig.maxTokens;
+      const threshold = compactionConfig.triggerThreshold || 0.8;
+
+      if (tokenCount > maxTokens * threshold) {
+        logger.info(
+          `[CompactionProcessor] Token count ${tokenCount} exceeds threshold ${maxTokens * threshold}. Triggering compaction.`,
+        );
+
+        let newHistoryContent = [...state.historyContent];
+        let events = [...state.events];
+
+        if (compactionConfig.strategy === "truncate") {
+          const historyLength = newHistoryContent.length;
+          if (historyLength > 2) {
+            const removeCount = Math.ceil((historyLength - 1) * 0.2);
+            logger.info(
+              `[CompactionProcessor] Truncating oldest ${removeCount} messages from history.`,
+            );
+            newHistoryContent.splice(0, removeCount);
+
+            events.push(
+              this.createEvent(AgentEventType.COMPACTION, streamId, {
+                role: "agent",
+                strategy: "truncate",
+                parts: [
+                  {
+                    type: "text",
+                    text: `[System: Context compacted to save tokens. Removed ${removeCount} older messages.]`,
+                  },
+                ],
+              } as Partial<CompactionEvent>),
+            );
+
+            // Rebuild request
+            const llmRequest = this.rebuildRequest(newHistoryContent);
+            return {
+              historyContent: newHistoryContent,
+              llmRequest,
+              events,
+            };
+          }
+        }
+
+        if (compactionConfig.strategy === "summarize") {
+          logger.info(
+            `[CompactionProcessor] Compacting history using UtilLlm.`,
+          );
+          const utilLlm = new UtilLlm(model);
+          try {
+            const summary = await utilLlm.compactHistory(newHistoryContent);
+
+            newHistoryContent = [
+              {
+                role: "agent",
+                parts: [
+                  {
+                    type: "text",
+                    text: `Summary of previous conversation:\n${summary}`,
+                  },
+                ],
+              },
+            ];
+
+            events.push(
+              this.createEvent(AgentEventType.COMPACTION, streamId, {
+                role: "agent",
+                strategy: "summarize",
+                parts: [
+                  {
+                    type: "text",
+                    text: `[System: Context compacted using LLM summarization.]`,
+                  },
+                ],
+              } as Partial<CompactionEvent>),
+            );
+
+            // Rebuild request
+            const llmRequest = this.rebuildRequest(newHistoryContent);
+            return {
+              historyContent: newHistoryContent,
+              llmRequest,
+              events,
+            };
+          } catch (error: any) {
+            logger.error(
+              `[CompactionProcessor] Compaction failed: ${error.message}`,
+            );
+          }
+        }
+      }
+    } catch (error: any) {
+      logger.error(
+        `[CompactionProcessor] Failed to count tokens or compact context: ${error.message}`,
+      );
+    }
+
+    return state;
+  }
+
+  private rebuildRequest(historyContent: Content[]) {
+    const lastContent = historyContent[historyContent.length - 1];
+    const historyForRequest = historyContent.slice(0, -1);
+    return buildLlmRequest({
+      agentName: this.options.requestBuilderOptions.agentName,
+      content: lastContent,
+      historyContent: historyForRequest,
+      tools: this.options.requestBuilderOptions.tools,
+      skills: this.options.requestBuilderOptions.skills,
+      description: this.options.requestBuilderOptions.description,
+      instructions: this.options.requestBuilderOptions.instructions,
+      thinkingConfig: this.options.requestBuilderOptions.thinkingConfig,
+    });
+  }
+
+  private createEvent(
+    type: AgentEventType,
+    streamId: string,
+    data: Partial<AgentEvent> = {},
+  ): AgentEvent {
+    return {
+      type,
+      id: randomUUID(),
+      streamId,
+      timestamp: new Date().toISOString(),
+      ...data,
+    } as AgentEvent;
+  }
+}

package/src/agent/request_processor/request_processor.ts

@@ -0,0 +1,13 @@
+import type { Content } from "../../content.js";
+import type { LlmRequest } from "../../model/request.js";
+import type { AgentEvent } from "../agent_event.js";
+
+export interface AgentState {
+  historyContent: Content[];
+  llmRequest?: LlmRequest;
+  events: AgentEvent[];
+}
+
+export interface RequestProcessor {
+  process(state: AgentState): Promise<AgentState>;
+}

package/src/cli/loader.ts

@@ -0,0 +1,27 @@
+import * as readline from "node:readline";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export class TerminalLoader {
+  private loadingInterval: NodeJS.Timeout | null = null;
+  private frameIndex = 0;
+
+  startLoading() {
+    if (this.loadingInterval) return;
+    this.frameIndex = 0;
+    this.loadingInterval = setInterval(() => {
+      readline.cursorTo(process.stdout, 0);
+      process.stdout.write(SPINNER_FRAMES[this.frameIndex]);
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+    }, 80);
+  }
+
+  stopLoading() {
+    if (this.loadingInterval) {
+      clearInterval(this.loadingInterval);
+      this.loadingInterval = null;
+      readline.cursorTo(process.stdout, 0);
+      readline.clearLine(process.stdout, 0);
+    }
+  }
+}

package/src/cli/prompt_utils.ts

@@ -0,0 +1,19 @@
+export type UserAction = "accept" | "decline";
+
+/**
+ * Checks if a user answer means "yes".
+ * Matches "yes", "y", and "accept" (case-insensitive).
+ * Can specify a default value for empty input.
+ */
+export function isYes(answer: string, defaultYes = false): boolean {
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "") return defaultYes;
+  return trimmed === "yes" || trimmed === "y" || trimmed === "accept";
+}
+
+/**
+ * Parses a user answer to determine if it should be treated as an acceptance or decline.
+ */
+export function parseUserAction(answer: string): UserAction {
+  return isYes(answer) ? "accept" : "decline";
+}

package/src/cli/run_interactive_command.ts

@@ -0,0 +1,337 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { randomUUID } from "node:crypto";
+import * as readline from "node:readline";
+import { loadConfig } from "../config/config_loader.js";
+import { CoreAgentLoop, AgentLoopType } from "../core/loop.js";
+import {
+  AgentEventType,
+  type AgentEvent,
+  type UserInputRequestEvent,
+  type CompactionEvent,
+} from "../agent/agent_event.js";
+import { TerminalLoader } from "./loader.js";
+import { configStore } from "../config/config_store.js";
+import { projectService } from "../core/project_service.js";
+import type { ThinkingConfig } from "../model/request.js";
+import type { Session, SessionMetadata } from "../session/session.js";
+import { SessionFileService } from "../session/session_file_service.js";
+import { UserCommandType } from "../user_input.js";
+import { InitProjectCommandHandler } from "../command/init_project_command_handler.js";
+import { isYes, parseUserAction } from "./prompt_utils.js";
+
+export interface RunCommandOptions {
+  prompt?: string;
+  model?: string;
+  positionals: string[];
+}
+
+export async function runInteractiveCommand(options: RunCommandOptions) {
+  let prompt = options.prompt;
+  if (!prompt && options.positionals.length > 0) {
+    prompt = options.positionals.join(" ");
+  }
+
+  const config = await loadConfig();
+
+  if (options.model) {
+    config.models.main.modelName = options.model;
+  }
+
+  console.log(`Using model: ${config.models.main.modelName}`);
+
+  const rl = createInterface({ input, output });
+
+  if (config.thinkingConfig.enabled && !config.thinkingConfig.level) {
+    const validLevels = ["low", "medium", "high", "auto"];
+    let level: string | null = null;
+    while (!level) {
+      const answer = await rl.question(
+        "Select thinking level (low, medium, high, auto) [default: high]: ",
+      );
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        level = "high";
+      } else if (validLevels.includes(trimmed)) {
+        level = trimmed;
+      } else {
+        console.log(
+          "Invalid level. Please choose from: low, medium, high, auto",
+        );
+      }
+    }
+    config.thinkingConfig.level = level as ThinkingConfig["level"];
+    await configStore.set("thinking_level", level);
+    console.log(`Thinking level set to: ${level}`);
+  }
+
+  const sessionService = new SessionFileService();
+  const sessions = await sessionService.listSessions();
+  let sessionId: string | undefined = undefined;
+
+  if (sessions.length > 0) {
+    console.log("\nAvailable sessions:");
+    sessions.forEach((s, index) => {
+      console.log(`${index + 1}. ${getSessionName(s)}`);
+    });
+
+    const answer = await rl.question(
+      "\nSelect session number to resume or 'n' for new session [default: new]: ",
+    );
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed !== "" && trimmed !== "n") {
+      const selectedIndex = parseInt(trimmed, 10) - 1;
+      if (selectedIndex >= 0 && selectedIndex < sessions.length) {
+        sessionId = sessions[selectedIndex].id;
+        console.log(
+          `Resuming session: ${getSessionName(sessions[selectedIndex])}`,
+        );
+      } else {
+        console.log("Invalid selection. Starting a new session.");
+      }
+    }
+  }
+
+  if (!(await projectService.isInitialized())) {
+    const answer = await rl.question(
+      "\nProject has not been scanned yet. Initializing the project helps the LLM understand your codebase better and improves the quality of assistance.\nDo you want to run 'init' now? (yes/no) [default: yes]: ",
+    );
+    if (isYes(answer, true)) {
+      const handler = new InitProjectCommandHandler();
+      await handler.handle();
+    }
+  }
+
+  const loop = new CoreAgentLoop(config, sessionId);
+  const loader = new TerminalLoader();
+  let hasStreamed = false;
+  let isThinking = false;
+  const lastPrintedToolCalls = new Map<string, string>();
+  let pendingUserInputRequest: UserInputRequestEvent | null = null;
+
+  loop.on(AgentLoopType.AGENT_EVENT, (event: AgentEvent) => {
+    switch (event.type) {
+      case AgentEventType.START:
+        loader.startLoading();
+        hasStreamed = false;
+        lastPrintedToolCalls.clear();
+        break;
+      case AgentEventType.MESSAGE:
+        if (event.role === "agent" && event.parts) {
+          if (event.partial === true) {
+            hasStreamed = true;
+            loader.stopLoading();
+            for (const part of event.parts) {
+              if ("thought" in part && part.thought) {
+                if (!isThinking) {
+                  isThinking = true;
+                  rl.write("\x1b[2mThinking: ");
+                }
+                rl.write(part.thought);
+              } else if ("text" in part && part.text) {
+                if (isThinking) {
+                  readline.cursorTo(process.stdout, 0);
+                  readline.clearLine(process.stdout, 0);
+                  isThinking = false;
+                  rl.write("\x1b[0m"); // Reset style
+                }
+                rl.write(part.text);
+              }
+            }
+          } else {
+            if (hasStreamed) {
+              rl.write("\n");
+              break;
+            }
+            loader.stopLoading();
+            for (const part of event.parts) {
+              if ("text" in part && part.text) {
+                rl.write(part.text);
+              }
+            }
+            rl.write("\n");
+          }
+        }
+        break;
+      case AgentEventType.COMPACTION:
+        loader.stopLoading();
+        const compactionEvent = event as CompactionEvent;
+        console.log(
+          `\n\x1b[36m[Compaction: ${compactionEvent.strategy}]\x1b[0m`,
+        );
+        if (compactionEvent.parts) {
+          for (const part of compactionEvent.parts) {
+            if ("text" in part && part.text) {
+              console.log(part.text);
+            }
+          }
+        }
+        break;
+      case AgentEventType.END:
+        loader.stopLoading();
+        break;
+      case AgentEventType.ERROR:
+        loader.stopLoading();
+        console.error(`\nAgent Error: ${event.errorMessage}`);
+        break;
+      case AgentEventType.TOOL_CALL:
+        const contentStr = JSON.stringify({
+          name: event.name,
+          args: event.args,
+        });
+        if (lastPrintedToolCalls.get(event.requestId) === contentStr) {
+          break;
+        }
+        lastPrintedToolCalls.set(event.requestId, contentStr);
+
+        loader.stopLoading();
+        console.log(`\n\x1b[33m[Tool Call: ${event.name}]\x1b[0m`);
+        console.log(JSON.stringify(event.args, null, 2));
+        break;
+      case AgentEventType.TOOL_RESPONSE:
+        console.log(`\n\x1b[32m[Tool Response: ${event.name}]\x1b[0m`);
+        if (event.error) {
+          console.log(`\x1b[31mError: ${event.error}\x1b[0m`);
+        } else {
+          if (typeof event.result === "string") {
+            console.log(event.result);
+          } else {
+            console.log(JSON.stringify(event.result, null, 2));
+          }
+        }
+        break;
+      case AgentEventType.USER_INPUT_REQUEST:
+        loader.stopLoading();
+        pendingUserInputRequest = event as UserInputRequestEvent;
+        break;
+      default:
+        break;
+    }
+  });
+
+  try {
+    if (prompt) {
+      console.log(`\nInitial prompt: ${prompt}`);
+      await loop.run(prompt);
+
+      while (pendingUserInputRequest) {
+        const request = pendingUserInputRequest;
+        pendingUserInputRequest = null;
+        const answer = await rl.question(
+          `\n${(request as UserInputRequestEvent).message} (yes/no): `,
+        );
+        const action = parseUserAction(answer);
+
+        await loop.run({
+          type: AgentEventType.USER_INPUT_RESPONSE,
+          id: randomUUID(),
+          streamId: (request as UserInputRequestEvent).streamId,
+          timestamp: new Date().toISOString(),
+          role: "user",
+          requestId: (request as UserInputRequestEvent).requestId,
+          action,
+        });
+      }
+    }
+
+    while (true) {
+      const answer = await rl.question("\nUser > ");
+      const trimmedAnswer = answer.trim();
+
+      if (!trimmedAnswer) {
+        continue;
+      }
+
+      if (
+        trimmedAnswer.toLowerCase() === "exit" ||
+        trimmedAnswer.toLowerCase() === "quit"
+      ) {
+        console.log("Exiting...");
+        break;
+      }
+
+      if (trimmedAnswer.startsWith("/plan")) {
+        const task = trimmedAnswer.substring(5).trim();
+        await loop.run({ command: UserCommandType.PLAN, task: task });
+
+        while (pendingUserInputRequest) {
+          const request = pendingUserInputRequest;
+          pendingUserInputRequest = null;
+          const answer = await rl.question(
+            `\n${(request as UserInputRequestEvent).message} (yes/no): `,
+          );
+          const action = parseUserAction(answer);
+
+          await loop.run({
+            type: AgentEventType.USER_INPUT_RESPONSE,
+            id: randomUUID(),
+            streamId: (request as UserInputRequestEvent).streamId,
+            timestamp: new Date().toISOString(),
+            role: "user",
+            requestId: (request as UserInputRequestEvent).requestId,
+            action,
+          });
+        }
+        continue;
+      }
+
+      if (trimmedAnswer.startsWith("/init")) {
+        const handler = new InitProjectCommandHandler();
+        await handler.handle();
+        continue;
+      }
+
+      await loop.run(trimmedAnswer);
+
+      while (pendingUserInputRequest) {
+        const request = pendingUserInputRequest;
+        pendingUserInputRequest = null;
+        const answer = await rl.question(
+          `\n${(request as UserInputRequestEvent).message} (yes/no): `,
+        );
+        const action = parseUserAction(answer);
+
+        await loop.run({
+          type: AgentEventType.USER_INPUT_RESPONSE,
+          id: randomUUID(),
+          streamId: (request as UserInputRequestEvent).streamId,
+          timestamp: new Date().toISOString(),
+          role: "user",
+          requestId: (request as UserInputRequestEvent).requestId,
+          action,
+        });
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function formatDate(date: Date): string {
+  const now = new Date();
+  const isToday =
+    date.getDate() === now.getDate() &&
+    date.getMonth() === now.getMonth() &&
+    date.getFullYear() === now.getFullYear();
+
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+
+  if (isToday) {
+    return `today ${hours}:${minutes}`;
+  } else {
+    const month = (date.getMonth() + 1).toString().padStart(2, "0");
+    const day = date.getDate().toString().padStart(2, "0");
+    return `${date.getFullYear()}-${month}-${day} ${hours}:${minutes}`;
+  }
+}
+
+function getSessionName(session: Session | SessionMetadata): string {
+  if (!session.title) {
+    return session.id;
+  }
+
+  const date = new Date(session.timestamp);
+  const formattedDate = formatDate(date);
+  return `${session.title} (${formattedDate})`;
+}

package/src/cli/run_noninteractive_command.ts

@@ -0,0 +1,74 @@
+import { loadConfig } from "../config/config_loader.js";
+import { CoreAgentLoop, AgentLoopType } from "../core/loop.js";
+import { AgentEventType, type AgentEvent } from "../agent/agent_event.js";
+
+export interface RunCommandOptions {
+  prompt?: string;
+  model?: string;
+  positionals: string[];
+}
+
+export async function runNoninteractiveCommand(options: RunCommandOptions) {
+  let prompt = options.prompt;
+  if (!prompt && options.positionals.length > 0) {
+    prompt = options.positionals.join(" ");
+  }
+
+  if (!prompt) {
+    console.error("Error: Please provide a prompt for non-interactive mode.");
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  if (options.model) {
+    config.models.main.modelName = options.model;
+  }
+
+  console.log(`Using model: ${config.models.main.modelName}`);
+
+  const loop = new CoreAgentLoop(config);
+  const lastPrintedToolCalls = new Map<string, string>();
+
+  loop.on(AgentLoopType.AGENT_EVENT, (event: AgentEvent) => {
+    switch (event.type) {
+      case AgentEventType.START:
+        console.log("\n--- Agent Started ---");
+        lastPrintedToolCalls.clear();
+        break;
+      case AgentEventType.MESSAGE:
+        if (event.role === "agent" && event.parts) {
+          for (const part of event.parts) {
+            if ("text" in part && part.text) {
+              process.stdout.write(part.text);
+            }
+          }
+        }
+        break;
+      case AgentEventType.END:
+        console.log("\n--- Agent Ended ---");
+        console.log(`Reason: ${event.reason}`);
+        break;
+      case AgentEventType.ERROR:
+        console.error(`\nAgent Error: ${event.errorMessage}`);
+        break;
+      case AgentEventType.TOOL_CALL:
+        const contentStr = JSON.stringify({ name: event.name, args: event.args });
+        if (lastPrintedToolCalls.get(event.requestId) === contentStr) {
+          break;
+        }
+        lastPrintedToolCalls.set(event.requestId, contentStr);
+
+        console.log(`\n[Tool Call: ${event.name}]`);
+        break;
+      case AgentEventType.TOOL_RESPONSE:
+        console.log(`\n[Tool Response: ${event.name}]`);
+        break;
+      default:
+        break;
+    }
+  });
+
+  console.log(`\nPrompt: ${prompt}`);
+  await loop.run(prompt);
+}