@kalenkevich/agent_007 0.0.1

package/src/cli_entrypoint.ts

@@ -0,0 +1,128 @@
+#! /usr/bin/env node
+
+import { parseArgs } from "node:util";
+import { runNoninteractiveCommand } from "./cli/run_noninteractive_command.js";
+import { runInteractiveCommand } from "./cli/run_interactive_command.js";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { configStore } from "./config/config_store.js";
+import { InitProjectCommandHandler } from "./command/init_project_command_handler.js";
+
+const options = {
+  prompt: {
+    type: "string" as const,
+    short: "p",
+  },
+  model: {
+    type: "string" as const,
+    short: "m",
+  },
+  help: {
+    type: "boolean" as const,
+    short: "h",
+  },
+  debug: {
+    type: "boolean" as const,
+  },
+};
+
+const USAGE = `
+Usage: agent007 <command> [options]
+
+Commands:
+  i, interactive     Run the agent interactively (REPL)
+  ni, noninteractive  Run the agent with a prompt and exit
+  init               Initialize project and define constants
+
+Options:
+  -p, --prompt <string>  The task for the agent
+  -m, --model <string>   Override the default model
+  -h, --help             Show this help message
+  --debug                Enable debug mode (writes to debug.log)
+`;
+
+async function ensureApiKey() {
+  let geminiApiKey =
+    process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || "";
+  geminiApiKey = geminiApiKey.trim();
+
+  if (!geminiApiKey) {
+    geminiApiKey = (await configStore.getApiKey()) || "";
+  }
+
+  if (!geminiApiKey) {
+    const rl = createInterface({ input, output });
+    try {
+      const answer = await rl.question("Please enter your Gemini API key: ");
+      geminiApiKey = answer.trim();
+      if (geminiApiKey) {
+        await configStore.setApiKey(geminiApiKey);
+      }
+    } finally {
+      rl.close();
+    }
+  }
+
+  if (geminiApiKey) {
+    process.env.GEMINI_API_KEY = geminiApiKey;
+  }
+}
+
+async function main() {
+  try {
+    const { values, positionals } = parseArgs({
+      options,
+      allowPositionals: true,
+    });
+
+    if (values.help) {
+      console.log(USAGE);
+      return;
+    }
+
+    if (values.debug) {
+      console.log("Debug mode: enabled");
+      process.env.DEBUG_LOGGER = "true";
+    }
+
+    await ensureApiKey();
+
+    const command = positionals[0];
+
+    if (!command || command === "i" || command === "interactive") {
+      await runInteractiveCommand({
+        prompt: values.prompt,
+        model: values.model,
+        positionals: positionals.slice(1),
+      });
+
+      return;
+    }
+
+    if (command === "ni" || command === "run_noninteractive") {
+      await runNoninteractiveCommand({
+        prompt: values.prompt,
+        model: values.model,
+        positionals: positionals.slice(1),
+      });
+
+      return;
+    }
+
+    if (command === "init") {
+      const handler = new InitProjectCommandHandler();
+      await handler.handle();
+      return;
+    }
+
+    console.error(`Unknown command: ${command}`);
+    console.log("Use --help to see available commands.");
+    process.exit(1);
+  } catch (error: any) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+}
+
+main();
+

package/src/command/commnad_handler.ts

@@ -0,0 +1,3 @@
+export interface CommandHandler {
+  handle(): Promise<void>;
+}

package/src/command/init_project_command_handler.ts

@@ -0,0 +1,66 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { projectService } from "../core/project_service.js";
+import { loadConfig } from "../config/config_loader.js";
+import { UtilLlm } from "../model/util_llm.js";
+import { resolveLlmModel } from "../model/registry.js";
+import { type CommandHandler } from "./commnad_handler.js";
+import { logger } from "../logger.js";
+
+export class InitProjectCommandHandler implements CommandHandler {
+  async handle(): Promise<void> {
+    const cwd = process.cwd();
+    const projectId = projectService.getProjectId();
+
+    logger.info(`Initializing project in ${cwd}`);
+    logger.info(`Project ID: ${projectId}`);
+
+    // Gather context
+    let context = `Project Path: ${cwd}\n\n`;
+
+    // List top level files and dirs
+    try {
+      const files = await fs.readdir(cwd);
+      context += `Top level files and directories:\n${files.join("\n")}\n\n`;
+    } catch (e) {
+      logger.error("Failed to read directory:", e);
+    }
+
+    // Read package.json if exists
+    const packageJsonPath = path.join(cwd, "package.json");
+    try {
+      const packageJson = await fs.readFile(packageJsonPath, "utf-8");
+      context += `package.json:\n${packageJson}\n\n`;
+    } catch (e) {
+      // Ignore if doesn't exist
+    }
+
+    // Read tsconfig.json if exists
+    const tsconfigPath = path.join(cwd, "tsconfig.json");
+    try {
+      const tsconfig = await fs.readFile(tsconfigPath, "utf-8");
+      context += `tsconfig.json:\n${tsconfig}\n\n`;
+    } catch (e) {
+      // Ignore if doesn't exist
+    }
+
+    // Load config for UtilLlm
+    const config = await loadConfig();
+    const utilModelConfig = config.models.util;
+    if (!utilModelConfig) {
+      throw new Error("Util model config is missing");
+    }
+    const UtilModelClass = resolveLlmModel(utilModelConfig.modelName);
+    const utilLlm = new UtilLlm(new UtilModelClass(utilModelConfig));
+
+    logger.info("Scanning project constants with LLM...");
+    const constants = await utilLlm.scanProjectConstants(context);
+
+    logger.info("Saving constants...");
+    await projectService.saveConstants(constants);
+
+    logger.info(
+      `Project constants saved to ${projectService.getConstantsPath()} in config store.`,
+    );
+  }
+}

package/src/config/app_dir.ts

@@ -0,0 +1,4 @@
+import * as path from "node:path";
+import * as os from "node:os";
+
+export const APP_FILE_DIR = path.join(os.homedir(), ".agent_007");

package/src/config/config.ts

@@ -0,0 +1,24 @@
+import { type ThinkingConfig } from "../model/request.js";
+
+export interface ModelConfig {
+  modelName: string;
+  apiKey: string;
+  tokenLimit?: number;
+}
+
+export interface CompactionConfig {
+  enabled: boolean;
+  strategy: "truncate" | "summarize" | "hybrid" | "compact";
+  maxTokens: number;
+  triggerThreshold?: number;
+}
+
+export interface Config {
+  models: {
+    main: ModelConfig;
+    fallback?: ModelConfig[];
+    util?: ModelConfig;
+  };
+  thinkingConfig: ThinkingConfig;
+  compactionConfig: CompactionConfig;
+}

package/src/config/config_loader.ts

@@ -0,0 +1,57 @@
+import type { ThinkingConfig } from "../model/request.js";
+import type { Config } from "./config.js";
+import { configStore } from "./config_store.js";
+
+export async function loadConfig(): Promise<Config> {
+  const geminiApiKey =
+    process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || "";
+
+  let thinkingLevel = process.env.THINKING_LEVEL as ThinkingConfig["level"] | undefined;
+  if (!thinkingLevel) {
+    const storedLevel = await configStore.get("thinking_level");
+    if (storedLevel) {
+      thinkingLevel = storedLevel as ThinkingConfig["level"];
+    }
+  }
+
+  return {
+    models: {
+      main: {
+        modelName: process.env.MODEL_NAME || "gemini-3.1-pro-preview",
+        apiKey: geminiApiKey,
+      },
+      fallback: [
+        {
+          modelName: process.env.FALLBACK_MODEL_NAME || "gemini-2.5-pro",
+          apiKey: geminiApiKey,
+        },
+        {
+          modelName:
+            process.env.FALLBACK_MODEL_NAME || "gemini-3-flash-preview",
+          apiKey: geminiApiKey,
+        },
+        {
+          modelName: process.env.FALLBACK_MODEL_NAME || "gemini-2.5-flash",
+          apiKey: geminiApiKey,
+        },
+      ],
+      util: {
+        modelName:
+          process.env.UTIL_MODEL_NAME || "gemini-3.1-flash-lite-preview",
+        apiKey: geminiApiKey,
+      },
+    },
+    thinkingConfig: {
+      enabled: process.env.ENABLE_THINKING !== "false",
+      level: thinkingLevel,
+    },
+    compactionConfig: {
+      maxTokens: 10000,
+      enabled: process.env.ENABLE_COMPACTION !== "false",
+      strategy: process.env.COMPACTION_STRATEGY as
+        | "summarize"
+        | "truncate"
+        | "hybrid",
+    },
+  };
+}

package/src/config/config_store.ts

@@ -0,0 +1,50 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { APP_FILE_DIR } from "./app_dir.js";
+
+export class ConfigStore {
+  private configDir: string;
+
+  constructor() {
+    this.configDir = APP_FILE_DIR;
+  }
+
+  private async ensureDir() {
+    await fs.mkdir(this.configDir, { recursive: true });
+  }
+
+  async getApiKey(): Promise<string | null> {
+    const keyFilePath = path.join(this.configDir, "api_key");
+    try {
+      const content = await fs.readFile(keyFilePath, "utf-8");
+      return content.trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async setApiKey(key: string): Promise<void> {
+    await this.ensureDir();
+    const keyFilePath = path.join(this.configDir, "api_key");
+    await fs.writeFile(keyFilePath, key.trim(), "utf-8");
+  }
+
+  async get(filename: string): Promise<string | null> {
+    const filePath = path.join(this.configDir, filename);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return content.trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async set(filename: string, value: string): Promise<void> {
+    await this.ensureDir();
+    const filePath = path.join(this.configDir, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, value.trim(), "utf-8");
+  }
+}
+
+export const configStore = new ConfigStore();

package/src/content.ts

@@ -0,0 +1,87 @@
+export type ContentRole = "user" | "agent" | "developer";
+
+export interface Content {
+  role: ContentRole;
+  parts: ContentPart[];
+}
+
+export type ContentPart =
+  | TextContentPart
+  | ThoughtContentPart
+  | MediaContentPart
+  | FunctionCallContentPart
+  | FunctionResponseContentPart;
+
+export interface TextContentPart {
+  type: "text";
+  text: string;
+}
+
+export function isTextContentPart(part: ContentPart): part is TextContentPart {
+  return part.type === "text";
+}
+
+export interface ThoughtContentPart {
+  type: "thought";
+  thought: string;
+  thoughtSignature?: string;
+}
+
+export function isThoughtContentPart(
+  part: ContentPart,
+): part is ThoughtContentPart {
+  return part.type === "thought";
+}
+
+export interface MediaContentPart {
+  type: "media";
+  data?: string;
+  uri?: string;
+  mimeType?: string;
+}
+
+export function isMediaContentPart(
+  part: ContentPart,
+): part is MediaContentPart {
+  return part.type === "media";
+}
+
+export interface FunctionCallContentPart {
+  type: "function_call";
+  id?: string;
+  args?: Record<string, unknown>;
+  partialArgs?: PartialArg[];
+  name?: string;
+  willContinue?: boolean;
+  thoughtSignature?: string;
+}
+
+export function isFunctionCallContentPart(
+  part: ContentPart,
+): part is FunctionCallContentPart {
+  return part.type === "function_call";
+}
+
+export interface FunctionResponseContentPart {
+  type: "function_response";
+  willContinue?: boolean;
+  id?: string;
+  name?: string;
+  response?: Record<string, unknown>;
+  thoughtSignature?: string;
+}
+
+export function isFunctionResponseContentPart(
+  part: ContentPart,
+): part is FunctionResponseContentPart {
+  return part.type === "function_response";
+}
+
+export interface PartialArg {
+  boolValue?: boolean;
+  jsonPath?: string;
+  nullValue?: "NULL_VALUE";
+  numberValue?: number;
+  stringValue?: string;
+  willContinue?: boolean;
+}

package/src/core/functions.ts

@@ -0,0 +1,7 @@
+import {randomUUID} from 'node:crypto';
+
+const FUNCTION_CALL_ID_PREFIX = 'kalenkevich_agent_';
+
+export function generateClientFunctionCallId(): string {
+  return `${FUNCTION_CALL_ID_PREFIX}${randomUUID()}`;
+}

package/src/core/loop.ts

@@ -0,0 +1,165 @@
+import { EventEmitter } from 'node:events';
+import type { Agent } from "../agent/agent.js";
+import type { UserInput } from "../user_input.js";
+import { CliAgent } from "../agent/cli_agent/cli_agent.js";
+import { Run } from "./run.js";
+import type { Config } from "../config/config.js";
+import { AdaptiveLlmModel } from "../model/adaptive_model.js";
+import { randomUUID } from "node:crypto";
+import { UtilLlm } from "../model/util_llm.js";
+import {
+  AgentEventType,
+  type AgentEvent,
+  type ErrorEvent,
+} from "../agent/agent_event.js";
+import { logger } from "../logger.js";
+import { SessionFileService } from "../session/session_file_service.js";
+import { resolveLlmModel } from "../model/registry.js";
+import { projectService } from "./project_service.js";
+import { CLI_AGENT_SYSTEM_PROMPT } from "../agent/cli_agent/system_prompt.js";
+
+export enum AgentLoopType {
+  AGENT_EVENT = 'AGENT_EVENT',
+}
+
+export class CoreAgentLoop extends EventEmitter {
+  private agent?: Agent;
+  private initialized = false;
+  private currentRun?: Run;
+  private config: Config;
+  private sessionService: SessionFileService;
+  private sessionId?: string;
+  private utilLlm?: UtilLlm;
+  private sessionTitleGenerated = false;
+
+  constructor(config: Config, sessionId?: string) {
+    super();
+    this.config = config;
+    this.sessionId = sessionId;
+    this.sessionService = new SessionFileService();
+  }
+
+  private async init() {
+    if (this.initialized) {
+      return;
+    }
+
+    let history: AgentEvent[] = [];
+    if (this.sessionId) {
+      const session = await this.sessionService.getSession(this.sessionId);
+      history = session.events;
+    }
+
+    const model = new AdaptiveLlmModel(this.config.models);
+    const constantsStr = await projectService.getConstants();
+
+    let instructions = CLI_AGENT_SYSTEM_PROMPT;
+    if (constantsStr) {
+      instructions += `\n\nProject Constants and Conventions:\n${constantsStr}`;
+    }
+
+    this.agent = new CliAgent({
+      model: model,
+      thinkingConfig: this.config.thinkingConfig,
+      history,
+      instructions,
+    });
+
+    const utilModelConfig = this.config.models.util;
+    if (!utilModelConfig) {
+      throw new Error("Util model config is missing");
+    }
+    const UtilModelClass = resolveLlmModel(utilModelConfig.modelName);
+    this.utilLlm = new UtilLlm(new UtilModelClass(utilModelConfig));
+
+    if (!this.sessionId) {
+      const session = await this.sessionService.createSession(
+        this.agent.name,
+        [],
+      );
+      this.sessionId = session.id;
+    }
+
+    this.initialized = true;
+    logger.debug("[CoreAgentLoop] initialized");
+  }
+
+  async run(userInput: UserInput) {
+    logger.debug(
+      "[CoreAgentLoop] run called with input:",
+      JSON.stringify(userInput, null, 2),
+    );
+    await this.currentRun?.wait();
+    this.currentRun = new Run();
+    this.currentRun.start();
+
+    await this.init();
+
+    let streamId = "unknown";
+    try {
+      for await (const event of this.agent!.run(userInput)) {
+        streamId = event.streamId;
+
+        if (this.sessionId) {
+          this.sessionService.appendEvent(this.sessionId, event);
+        }
+
+        this.emit(AgentLoopType.AGENT_EVENT, event);
+      }
+
+      if (!this.sessionTitleGenerated && this.sessionId) {
+        const sessionMeta = await this.sessionService.getSessionMetadata(
+          this.sessionId,
+        );
+        if (sessionMeta && !sessionMeta.title) {
+          const session = await this.sessionService.getSession(this.sessionId);
+          const userMessages = session.events.filter(
+            (e) => e.type === AgentEventType.MESSAGE && e.role === "user",
+          );
+          const agentMessages = session.events.filter(
+            (e) => e.type === AgentEventType.MESSAGE && e.role === "agent",
+          );
+
+          if (userMessages.length >= 1 && agentMessages.length >= 1) {
+            const title = await this.utilLlm!.generateSessionTitle(
+              session.events,
+            );
+            await this.sessionService.updateSession(this.sessionId, {
+              title,
+            });
+            this.sessionTitleGenerated = true;
+            logger.debug(`[CoreAgentLoop] Generated session title: ${title}`);
+          }
+        }
+      }
+    } catch (e: unknown) {
+      logger.error("[CoreAgentLoop] run error:", e);
+      const error = e as Error;
+      const errorEvent: ErrorEvent = {
+        id: randomUUID(),
+        streamId: streamId,
+        timestamp: new Date().toISOString(),
+        role: "agent",
+        type: AgentEventType.ERROR,
+        statusCode: 500,
+        errorMessage: error.message || String(error),
+        fatal: true,
+      };
+
+      if (this.sessionId) {
+        this.sessionService.appendEvent(this.sessionId, errorEvent);
+      }
+
+      this.emit(AgentLoopType.AGENT_EVENT, errorEvent);
+    } finally {
+      this.currentRun.finish();
+      this.currentRun = undefined;
+    }
+  }
+
+  async abort() {
+    if (this.currentRun) {
+      this.agent?.abort();
+    }
+  }
+}

package/src/core/project_service.ts

@@ -0,0 +1,38 @@
+import { createHash } from "node:crypto";
+import { configStore } from "../config/config_store.js";
+
+export class ProjectService {
+  private cwd: string;
+  private projectId: string;
+
+  constructor(cwd: string = process.cwd()) {
+    this.cwd = cwd;
+    this.projectId = createHash("sha256").update(this.cwd).digest("hex");
+  }
+
+  getProjectId(): string {
+    return this.projectId;
+  }
+
+  getConstantsPath(): string {
+    return `projects/${this.projectId}/constants.json`;
+  }
+
+  async getConstants(): Promise<string | null> {
+    return await configStore.get(this.getConstantsPath());
+  }
+
+  async saveConstants(constants: any): Promise<void> {
+    await configStore.set(
+      this.getConstantsPath(),
+      JSON.stringify(constants, null, 2),
+    );
+  }
+
+  async isInitialized(): Promise<boolean> {
+    const constants = await this.getConstants();
+    return constants !== null;
+  }
+}
+
+export const projectService = new ProjectService();

package/src/core/run.ts

@@ -0,0 +1,36 @@
+interface Deferred {
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (error: Error) => void;
+}
+
+function createDeferred(): Deferred {
+  let resolve: () => void;
+  let reject: (error: Error) => void;
+  const promise = new Promise<void>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve!, reject: reject! };
+}
+
+export class Run {
+  private deferred?: Deferred;
+
+  start() {
+    this.deferred = createDeferred();
+  }
+
+  finish() {
+    this.deferred?.resolve();
+    this.deferred = undefined;
+  }
+
+  wait() {
+    if (!this.deferred) {
+      return Promise.resolve();
+    }
+
+    return this.deferred.promise;
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { type Agent } from "./agent/agent.js";