@kalenkevich/agent_007 0.0.1

package/src/model/util_llm.ts

@@ -0,0 +1,167 @@
+import type { LlmModel } from "./model.js";
+import { type AgentEvent, isMessageEvent } from "../agent/agent_event.js";
+import type { Content, TextContentPart } from "../content.js";
+import { logger } from "../logger.js";
+
+export class UtilLlm {
+  private model: LlmModel;
+
+  constructor(model: LlmModel) {
+    this.model = model;
+  }
+
+  async generateSessionTitle(events: AgentEvent[]): Promise<string> {
+    const conversationText = events
+      .filter(isMessageEvent)
+      .map((event) => {
+        const role = event.role === "user" ? "User" : "Agent";
+        const text = event.parts
+          .filter((part): part is TextContentPart => part.type === "text")
+          .map((part) => part.text)
+          .join(" ");
+        return `[${role}]: ${text}`;
+      })
+      .join("\n");
+
+    if (!conversationText) {
+      return "New Session";
+    }
+
+    const prompt = `Based on the following conversation, generate a short, user-friendly title (3-5 words). Do not use quotes or special characters in the title.\n\nConversation:\n${conversationText}\n\nTitle:`;
+
+    const request = {
+      contents: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: prompt }],
+        },
+      ],
+      systemInstructions:
+        "You are a helpful assistant that generates concise titles for conversations.",
+    };
+
+    try {
+      const generator = this.model.run(request);
+      let title = "";
+      for await (const response of generator) {
+        if (response.errorMessage) {
+          throw new Error(response.errorMessage);
+        }
+        if (response.content && response.content.parts) {
+          for (const part of response.content.parts) {
+            if (part.type === "text") {
+              title += part.text;
+            }
+          }
+        }
+      }
+      return title.trim() || "New Session";
+    } catch (e) {
+      console.error("Failed to generate session title:", e);
+      return "New Session";
+    }
+  }
+
+  async compactHistory(contents: Content[]): Promise<string> {
+    const conversationText = contents
+      .map((content) => {
+        const role = content.role === "user" ? "User" : "Agent";
+        const text = content.parts
+          .filter((part): part is TextContentPart => part.type === "text")
+          .map((part) => part.text)
+          .join(" ");
+        return `[${role}]: ${text}`;
+      })
+      .join("\n");
+
+    const prompt = `Summarize the following conversation history strictly retaining facts, code snippets, and user preferences. Be concise.\n\nConversation:\n${conversationText}\n\nSummary:`;
+
+    const request = {
+      contents: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: prompt }],
+        },
+      ],
+      systemInstructions:
+        "You are a helpful assistant that summarizes conversation history.",
+    };
+
+    try {
+      const generator = this.model.run(request);
+      let summary = "";
+      for await (const response of generator) {
+        if (response.errorMessage) {
+          throw new Error(response.errorMessage);
+        }
+        if (response.content && response.content.parts) {
+          for (const part of response.content.parts) {
+            if (part.type === "text") {
+              summary += part.text;
+            }
+          }
+        }
+      }
+      return summary.trim();
+    } catch (e) {
+      logger.error("Failed to compact history:", e);
+      throw e;
+    }
+  }
+
+  async scanProjectConstants(context: string): Promise<Record<string, any>> {
+    const prompt = `Analyze the following project information and define project constants.
+Identify:
+- language, framework, package managers, build tools
+- project structure
+- coding style, rules and conventions
+
+Output the result as a JSON object. Do not include markdown formatting in the response, just the raw JSON.
+
+Project Info:
+${context}
+`;
+
+    const request = {
+      contents: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: prompt }],
+        },
+      ],
+      systemInstructions:
+        "You are a helpful assistant that analyzes codebases and extracts project conventions and constants in JSON format.",
+    };
+
+    try {
+      const generator = this.model.run(request);
+      let resultStr = "";
+      for await (const response of generator) {
+        if (response.errorMessage) {
+          throw new Error(response.errorMessage);
+        }
+        if (response.content && response.content.parts) {
+          for (const part of response.content.parts) {
+            if (part.type === "text") {
+              resultStr += part.text;
+            }
+          }
+        }
+      }
+      
+      let cleanedStr = resultStr.trim();
+      if (cleanedStr.startsWith("\`\`\`json")) {
+        cleanedStr = cleanedStr.substring(7);
+      }
+      if (cleanedStr.endsWith("\`\`\`")) {
+        cleanedStr = cleanedStr.substring(0, cleanedStr.length - 3);
+      }
+      cleanedStr = cleanedStr.trim();
+
+      return JSON.parse(cleanedStr);
+    } catch (e) {
+      logger.error("Failed to scan project constants:", e);
+      throw e;
+    }
+  }
+}

package/src/session/session.ts

@@ -0,0 +1,16 @@
+import { type AgentEvent } from "../agent/agent_event.js";
+
+export interface SessionMetadata {
+  id: string;
+  title?: string;
+  agentName: string;
+  timestamp: string;
+}
+
+export interface Session extends SessionMetadata {
+  id: string;
+  title?: string;
+  events: AgentEvent[];
+  agentName: string;
+  timestamp: string;
+}

package/src/session/session_file_service.ts

@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import type { Session, SessionMetadata } from "./session.js";
+import { type AgentEvent } from "../agent/agent_event.js";
+import { APP_FILE_DIR } from "../config/app_dir.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export class SessionFileService {
+  private rootDir: string;
+  private initialized: boolean = false;
+  private locks: Map<string, Promise<void>> = new Map();
+
+  constructor() {
+    this.rootDir = path.join(APP_FILE_DIR, "sessions");
+  }
+
+  private async init() {
+    if (this.initialized) {
+      return;
+    }
+
+    await fs.mkdir(this.rootDir, { recursive: true });
+  }
+
+  private async lock(sessionId: string): Promise<() => void> {
+    let unlock: () => void = () => {};
+    const previous = this.locks.get(sessionId) || Promise.resolve();
+
+    const current = new Promise<void>((r) => {
+      unlock = r;
+    });
+
+    this.locks.set(
+      sessionId,
+      previous.then(() => current),
+    );
+
+    await previous;
+
+    return unlock;
+  }
+
+  async getSession(sessionId: string): Promise<Session> {
+    const sessionFilePath = getSessionFileName(this.rootDir, sessionId);
+    const metaFilePath = getSessionMetadataFileName(this.rootDir, sessionId);
+    const session = await loadFileData<Session>(sessionFilePath);
+    const sessionMeta = await loadFileData<SessionMetadata>(metaFilePath);
+
+    if (!session || !sessionMeta) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    return {
+      ...session,
+      ...sessionMeta,
+    } as Session;
+  }
+
+  async getSessionMetadata(
+    sessionId: string,
+  ): Promise<SessionMetadata | undefined> {
+    const metaFilePath = getSessionMetadataFileName(this.rootDir, sessionId);
+    const sessionMeta = await loadFileData<SessionMetadata>(metaFilePath);
+
+    return sessionMeta;
+  }
+
+  async createSession(
+    agentName: string,
+    events: AgentEvent[],
+  ): Promise<Session> {
+    await this.init();
+
+    const session: Session = {
+      id: randomUUID(),
+      agentName: agentName,
+      events: events,
+      timestamp: new Date().toISOString(),
+    };
+
+    const sessionDir = path.join(this.rootDir, session.id);
+    await fs.mkdir(sessionDir, { recursive: true });
+
+    await saveToFile(getSessionMetadataFileName(this.rootDir, session.id), {
+      title: session.title,
+      agentName: session.agentName,
+      timestamp: session.timestamp,
+    });
+    await saveToFile(getSessionFileName(this.rootDir, session.id), session);
+
+    return session;
+  }
+
+  async updateSession(
+    sessionId: string,
+    { title }: { title: string },
+  ): Promise<void> {
+    await this.init();
+    const unlock = await this.lock(sessionId);
+    try {
+      const metaFilePath = getSessionMetadataFileName(this.rootDir, sessionId);
+      const sessionMeta = (await loadFileData(metaFilePath)) as Session;
+
+      if (!sessionMeta) {
+        return;
+      }
+
+      sessionMeta.title = title;
+      await saveToFile(metaFilePath, sessionMeta);
+    } finally {
+      unlock();
+    }
+  }
+
+  async appendEvent(sessionId: string, agentEvent: AgentEvent): Promise<void> {
+    await this.init();
+    const unlock = await this.lock(sessionId);
+    try {
+      const sessionFilePath = getSessionFileName(this.rootDir, sessionId);
+      const session = (await loadFileData(sessionFilePath)) as Session;
+
+      if (!session) {
+        return;
+      }
+
+      session.events.push(agentEvent);
+
+      await saveToFile(sessionFilePath, session);
+    } finally {
+      unlock();
+    }
+  }
+
+  async listSessions(): Promise<Array<SessionMetadata>> {
+    await this.init();
+
+    const folders = await listFiles(this.rootDir);
+
+    const result = await Promise.all(
+      folders.map(async (f) => {
+        try {
+          return await loadFileData<SessionMetadata>(
+            path.join(this.rootDir, f, "metadata.json"),
+          );
+        } catch (e) {
+          console.warn(
+            `Failed to load metadata for session in folder ${f}:`,
+            e,
+          );
+          return undefined;
+        }
+      }),
+    );
+
+    return result.filter((f): f is SessionMetadata => !!f);
+  }
+}
+
+export async function listFiles(folderPath: string): Promise<string[]> {
+  try {
+    return await fs.readdir(folderPath);
+  } catch (e) {
+    console.error(`Failed to list files in folder ${folderPath}`, e);
+
+    return [];
+  }
+}
+
+export function getSessionFileName(rootDir: string, sessionId: string): string {
+  return path.join(rootDir, sessionId, "session.json");
+}
+
+export function getSessionMetadataFileName(
+  rootDir: string,
+  sessionId: string,
+): string {
+  return path.join(rootDir, sessionId, "metadata.json");
+}
+
+export async function saveToFile<T>(filePath: string, data: T): Promise<void> {
+  try {
+    await fs.writeFile(
+      filePath,
+      typeof data === "string" ? data : JSON.stringify(data, null, 2),
+      { encoding: "utf-8" },
+    );
+  } catch (e) {
+    console.error(`Failed to write file ${filePath}:`, e);
+
+    throw e;
+  }
+}
+
+export async function loadFileData<T>(
+  filePath: string,
+): Promise<T | undefined> {
+  try {
+    return JSON.parse(await fs.readFile(filePath, { encoding: "utf-8" })) as T;
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      return undefined;
+    }
+    console.error(`Failed to read or parse file ${filePath}:`, e);
+
+    throw e;
+  }
+}

package/src/skills/skill.ts

@@ -0,0 +1,38 @@
+import type { FunctionDeclaration } from "../tools/tool.js";
+import { Type } from "../tools/schema.js";
+
+export interface SkillFrontmatter {
+  name: string;
+  description: string;
+  license?: string;
+  compatibility?: string;
+  allowedTools?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface Script {
+  src: string;
+}
+
+export interface Resources {
+  references?: Record<string, string | Buffer>;
+  assets?: Record<string, string | Buffer>;
+  scripts?: Record<string, Script>;
+}
+
+export interface Skill {
+  frontmatter: SkillFrontmatter;
+  instructions: string;
+  resources?: Resources;
+}
+
+export function toFunctionDeclaration(skill: Skill): FunctionDeclaration {
+  return {
+    name: `${skill.frontmatter.name}_skill`,
+    description: skill.frontmatter.description,
+    parameters: {
+      type: Type.OBJECT,
+      properties: {},
+    },
+  };
+}

package/src/tools/build_in/find.ts

@@ -0,0 +1,80 @@
+import { FunctionalTool } from "../functional_tool.js";
+import { type Schema, Type } from "../schema.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const FIND_TOOL = new FunctionalTool({
+  name: "find",
+  description: "Finds files matching a pattern.",
+  params: {
+    type: Type.OBJECT,
+    properties: {
+      pattern: {
+        type: Type.STRING,
+        description:
+          "The regular expression pattern to match against file names.",
+      },
+      path: {
+        type: Type.STRING,
+        description: "The path to search in. Defaults to '.' if not specified.",
+      },
+    },
+    required: ["pattern"],
+  } as Schema,
+  output: {
+    type: Type.OBJECT,
+    properties: {
+      files: {
+        type: Type.ARRAY,
+        items: {
+          type: Type.STRING,
+        },
+        description: "List of matching file paths",
+      },
+    },
+  } as Schema,
+  execute: async (input: unknown) => {
+    const typedInput = input as { pattern: string; path?: string };
+    const patternStr = typedInput.pattern;
+    const searchPath = typedInput.path || ".";
+    const resolvedPath = path.resolve(searchPath);
+    const cwd = process.cwd();
+
+    if (!resolvedPath.startsWith(cwd)) {
+      throw new Error(
+        `Access denied: Path ${resolvedPath} is outside the project directory.`,
+      );
+    }
+
+    const regex = new RegExp(patternStr);
+    const files: string[] = [];
+
+    async function searchDir(dir: string) {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        // Match against the file/directory name
+        if (regex.test(entry.name)) {
+          files.push(path.relative(cwd, fullPath));
+        }
+
+        if (entry.isDirectory()) {
+          if (entry.name === ".git" || entry.name === "node_modules") {
+            continue;
+          }
+          await searchDir(fullPath);
+        }
+      }
+    }
+
+    const stats = await fs.stat(resolvedPath);
+    if (stats.isDirectory()) {
+      await searchDir(resolvedPath);
+    } else {
+      throw new Error(`Path ${resolvedPath} is not a directory.`);
+    }
+
+    return { files };
+  },
+});

package/src/tools/build_in/grep.ts

@@ -0,0 +1,101 @@
+import { FunctionalTool } from "../functional_tool.js";
+import { type Schema, Type } from "../schema.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const GREP_TOOL = new FunctionalTool({
+  name: "grep",
+  description: "Searches for a regular expression pattern in files.",
+  params: {
+    type: Type.OBJECT,
+    properties: {
+      pattern: {
+        type: Type.STRING,
+        description: "The regular expression pattern to search for.",
+      },
+      path: {
+        type: Type.STRING,
+        description: "The path to search in. Defaults to '.' if not specified.",
+      },
+    },
+    required: ["pattern"],
+  } as Schema,
+  output: {
+    type: Type.OBJECT,
+    properties: {
+      matches: {
+        type: Type.ARRAY,
+        items: {
+          type: Type.OBJECT,
+          properties: {
+            file: { type: Type.STRING },
+            line: { type: Type.INTEGER },
+            content: { type: Type.STRING },
+          },
+        },
+        description: "List of matches found",
+      },
+    },
+  } as Schema,
+  execute: async (input: unknown) => {
+    const typedInput = input as { pattern: string; path?: string };
+    const patternStr = typedInput.pattern;
+    const searchPath = typedInput.path || ".";
+    const resolvedPath = path.resolve(searchPath);
+    const cwd = process.cwd();
+
+    if (!resolvedPath.startsWith(cwd)) {
+      throw new Error(
+        `Access denied: Path ${resolvedPath} is outside the project directory.`,
+      );
+    }
+
+    const regex = new RegExp(patternStr);
+    const matches: Array<{ file: string; line: number; content: string }> = [];
+
+    async function searchDir(dir: string) {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === ".git" || entry.name === "node_modules") {
+            continue; // Skip these by default for sanity
+          }
+          await searchDir(fullPath);
+        } else if (entry.isFile()) {
+          await searchFile(fullPath);
+        }
+      }
+    }
+
+    async function searchFile(filePath: string) {
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            matches.push({
+              file: path.relative(cwd, filePath),
+              line: i + 1,
+              content: lines[i],
+            });
+          }
+        }
+      } catch (error) {
+        // Ignore files that cannot be read as text or other errors
+      }
+    }
+
+    // Check if resolvedPath is a file or directory
+    const stats = await fs.stat(resolvedPath);
+    if (stats.isFile()) {
+      await searchFile(resolvedPath);
+    } else if (stats.isDirectory()) {
+      await searchDir(resolvedPath);
+    } else {
+      throw new Error(`Path ${resolvedPath} is neither a file nor a directory.`);
+    }
+
+    return { matches };
+  },
+});

package/src/tools/build_in/index.ts

@@ -0,0 +1,13 @@
+import { LIST_DIR_TOOL } from "./list_dir.js";
+import { VIEW_FILE_TOOL } from "./view_file.js";
+import { WRITE_FILE_TOOL } from "./write_file.js";
+import { GREP_TOOL } from "./grep.js";
+import { FIND_TOOL } from "./find.js";
+
+export const BUILD_IN_TOOLS = [
+  LIST_DIR_TOOL,
+  VIEW_FILE_TOOL,
+  WRITE_FILE_TOOL,
+  GREP_TOOL,
+  FIND_TOOL,
+];

package/src/tools/build_in/list_dir.ts

@@ -0,0 +1,50 @@
+import { FunctionalTool } from "../functional_tool.js";
+import { type Schema, Type } from "../schema.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const LIST_DIR_TOOL = new FunctionalTool({
+  name: "list_dir",
+  description: "Lists the contents of a directory.",
+  params: {
+    type: Type.OBJECT,
+    properties: {
+      path: {
+        type: Type.STRING,
+        description:
+          "The directory path to list. Defaults to '.' if not specified.",
+      },
+    },
+  } as Schema,
+  output: {
+    type: Type.OBJECT,
+    properties: {
+      files: {
+        type: Type.ARRAY,
+        items: {
+          type: Type.STRING,
+        },
+        description: "List of file and directory names",
+      },
+    },
+  } as Schema,
+  execute: async (input: unknown) => {
+    const typedInput = input as { path?: string };
+    const dirPath = typedInput.path || ".";
+    const resolvedPath = path.resolve(dirPath);
+    const cwd = process.cwd();
+
+    if (!resolvedPath.startsWith(cwd)) {
+      throw new Error(
+        `Access denied: Path ${resolvedPath} is outside the project directory.`,
+      );
+    }
+
+    try {
+      const files = await fs.readdir(resolvedPath);
+      return { files };
+    } catch (error: any) {
+      throw new Error(`Failed to list directory: ${error.message}`);
+    }
+  },
+});