@cuylabs/agent-core 0.3.0 → 0.5.0

package/dist/chunk-BDBZ3SLK.js

@@ -0,0 +1,745 @@
+// src/storage/types.ts
+var STORAGE_VERSION = 1;
+
+// src/storage/utils.ts
+function generateEntryId(existingIds) {
+  for (let i = 0; i < 100; i++) {
+    const id = crypto.randomUUID().slice(0, 8);
+    if (!existingIds?.has(id)) return id;
+  }
+  return crypto.randomUUID();
+}
+function parseJSONL(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+      console.warn("[Storage] Skipping malformed JSONL line");
+    }
+  }
+  return entries;
+}
+function toJSONL(entry) {
+  return JSON.stringify(entry) + "\n";
+}
+function toJSONLBatch(entries) {
+  return entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+}
+function serializeMessage(message) {
+  const serialized = {
+    id: message.id,
+    role: message.role,
+    content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+    createdAt: message.createdAt.toISOString()
+  };
+  if (message.role === "user" && "system" in message) {
+    serialized.system = message.system;
+  }
+  if (message.role === "assistant") {
+    if ("finish" in message) serialized.finish = message.finish;
+    if ("tokens" in message) serialized.tokens = message.tokens;
+    if ("cost" in message) serialized.cost = message.cost;
+    if ("error" in message) serialized.error = message.error;
+    if ("toolCalls" in message && message.toolCalls) serialized.toolCalls = message.toolCalls;
+  }
+  if (message.role === "tool") {
+    if ("toolCallId" in message) serialized.toolCallId = message.toolCallId;
+    if ("toolName" in message) serialized.toolName = message.toolName;
+    if ("result" in message) serialized.result = message.result;
+  }
+  return serialized;
+}
+function deserializeMessage(serialized) {
+  const base = {
+    id: serialized.id,
+    createdAt: new Date(serialized.createdAt)
+  };
+  switch (serialized.role) {
+    case "user":
+      return {
+        ...base,
+        role: "user",
+        content: serialized.content,
+        system: serialized.system
+      };
+    case "assistant":
+      return {
+        ...base,
+        role: "assistant",
+        content: serialized.content,
+        finish: serialized.finish,
+        tokens: serialized.tokens,
+        cost: serialized.cost,
+        error: serialized.error,
+        toolCalls: serialized.toolCalls
+      };
+    case "tool":
+      return {
+        ...base,
+        role: "tool",
+        content: serialized.content,
+        toolCallId: serialized.toolCallId,
+        toolName: serialized.toolName,
+        result: serialized.result
+      };
+    case "system":
+      return {
+        ...base,
+        role: "system",
+        content: serialized.content
+      };
+    default:
+      throw new Error(`Unknown message role: ${serialized.role}`);
+  }
+}
+function createMessageEntry(message, parentId, existingIds) {
+  return {
+    type: "message",
+    id: generateEntryId(existingIds),
+    parentId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    message: serializeMessage(message)
+  };
+}
+function createMetadataEntry(updates, parentId, existingIds) {
+  return {
+    type: "metadata",
+    id: generateEntryId(existingIds),
+    parentId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...updates
+  };
+}
+function extractSessionInfo(entries, path) {
+  if (entries.length === 0) return null;
+  const header = entries[0];
+  if (header.type !== "header") return null;
+  let title = header.title;
+  let name;
+  let messageCount = 0;
+  let firstMessage;
+  let lastTimestamp = header.timestamp;
+  for (let i = 1; i < entries.length; i++) {
+    const entry = entries[i];
+    lastTimestamp = entry.timestamp;
+    if (entry.type === "message") {
+      messageCount++;
+      if (!firstMessage && entry.message.role === "user") {
+        firstMessage = entry.message.content.slice(0, 100);
+      }
+    }
+    if (entry.type === "metadata") {
+      if (entry.title !== void 0) title = entry.title;
+      if (entry.name !== void 0) name = entry.name;
+    }
+  }
+  return {
+    id: header.id,
+    path,
+    cwd: header.cwd,
+    title,
+    name,
+    parentSessionId: header.parentSessionId,
+    createdAt: new Date(header.timestamp),
+    updatedAt: new Date(lastTimestamp),
+    messageCount,
+    firstMessage
+  };
+}
+function getLeafId(entries) {
+  if (entries.length <= 1) return null;
+  const childMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type === "header") continue;
+    const e = entry;
+    const children = childMap.get(e.parentId) ?? [];
+    children.push(e.id);
+    childMap.set(e.parentId, children);
+  }
+  const _allIds = new Set(entries.slice(1).map((e) => e.id));
+  const hasChildren = /* @__PURE__ */ new Set();
+  for (const children of childMap.values()) {
+    for (const child of children) {
+      const entry = entries.find((e) => e.type !== "header" && e.id === child);
+      if (entry && entry.type !== "header") {
+        const parentId = entry.parentId;
+        if (parentId) hasChildren.add(parentId);
+      }
+    }
+  }
+  for (let i = entries.length - 1; i >= 1; i--) {
+    const entry = entries[i];
+    if (!hasChildren.has(entry.id)) {
+      return entry.id;
+    }
+  }
+  return null;
+}
+function buildEntryPath(entries, targetId) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type !== "header") {
+      byId.set(entry.id, entry);
+    }
+  }
+  const path = [];
+  let currentId = targetId;
+  while (currentId) {
+    const entry = byId.get(currentId);
+    if (!entry) break;
+    path.unshift(entry);
+    currentId = entry.parentId;
+  }
+  return path;
+}
+function buildMessagesFromEntries(entries, leafId) {
+  const targetLeaf = leafId ?? getLeafId(entries);
+  if (!targetLeaf) return [];
+  const path = buildEntryPath(entries, targetLeaf);
+  const messages = [];
+  let skipUntilId;
+  for (const entry of path) {
+    if (entry.type === "compaction") {
+      skipUntilId = entry.firstKeptEntryId;
+      messages.push({
+        id: entry.id,
+        role: "system",
+        content: `## Previous Conversation Summary
+
+${entry.summary}`,
+        createdAt: new Date(entry.timestamp)
+      });
+      continue;
+    }
+    if (skipUntilId && entry.id !== skipUntilId) {
+      continue;
+    }
+    if (entry.id === skipUntilId) {
+      skipUntilId = void 0;
+    }
+    if (entry.type === "message") {
+      messages.push(deserializeMessage(entry.message));
+    }
+  }
+  return messages;
+}
+
+// src/storage/memory.ts
+var MemoryStorage = class {
+  sessions = /* @__PURE__ */ new Map();
+  async create(header) {
+    if (this.sessions.has(header.id)) {
+      throw new Error(`Session already exists: ${header.id}`);
+    }
+    this.sessions.set(header.id, [header]);
+  }
+  async append(sessionId, entry) {
+    const entries = this.sessions.get(sessionId);
+    if (!entries) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    entries.push(entry);
+  }
+  async appendBatch(sessionId, entries) {
+    const existing = this.sessions.get(sessionId);
+    if (!existing) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    existing.push(...entries);
+  }
+  async read(sessionId) {
+    const entries = this.sessions.get(sessionId);
+    if (!entries) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return [...entries];
+  }
+  async delete(sessionId) {
+    return this.sessions.delete(sessionId);
+  }
+  async exists(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  async list() {
+    const infos = [];
+    for (const [id, entries] of this.sessions) {
+      const info = extractSessionInfo(entries, `memory://${id}`);
+      if (info) {
+        infos.push(info);
+      }
+    }
+    infos.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return infos;
+  }
+  async clear() {
+    this.sessions.clear();
+  }
+};
+
+// src/storage/file/helpers.ts
+import { appendFile, mkdir, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { basename, join } from "path";
+async function ensureStorageDirectory(directory) {
+  if (!existsSync(directory)) {
+    await mkdir(directory, { recursive: true });
+  }
+}
+function getSessionFilePath(directory, extension, sessionId) {
+  const safeId = sessionId.replace(/[^a-zA-Z0-9-_]/g, "_");
+  return join(directory, `${safeId}${extension}`);
+}
+async function loadEntriesFromDisk(filePath, sessionId) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return parseJSONL(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    throw error;
+  }
+}
+async function createSessionFile(filePath, header) {
+  await writeFile(filePath, toJSONL(header), "utf-8");
+}
+async function appendSessionEntry(filePath, entry) {
+  await appendFile(filePath, toJSONL(entry), "utf-8");
+}
+async function appendSessionEntries(filePath, entries) {
+  await appendFile(filePath, toJSONLBatch(entries), "utf-8");
+}
+function sessionFileExists(filePath) {
+  return existsSync(filePath);
+}
+async function deleteSessionFile(filePath) {
+  if (!existsSync(filePath)) {
+    return false;
+  }
+  try {
+    await unlink(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listSessionIds(directory, extension) {
+  try {
+    const files = await readdir(directory);
+    return files.filter((file) => file.endsWith(extension)).map((file) => basename(file, extension));
+  } catch {
+    return [];
+  }
+}
+async function clearSessionFiles(directory, extension) {
+  try {
+    const files = await readdir(directory);
+    await Promise.all(
+      files.filter((file) => file.endsWith(extension)).map((file) => unlink(join(directory, file)).catch(() => {
+      }))
+    );
+  } catch {
+  }
+}
+async function getSessionFileStats(filePath) {
+  try {
+    const info = await stat(filePath);
+    return {
+      size: info.size,
+      mtime: info.mtime
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/storage/file/storage.ts
+var FileStorage = class {
+  directory;
+  extension;
+  useCache;
+  cache = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(options) {
+    this.directory = options.directory;
+    this.extension = options.extension ?? ".jsonl";
+    this.useCache = options.cache ?? true;
+  }
+  async ensureDir() {
+    if (this.initialized) return;
+    await ensureStorageDirectory(this.directory);
+    this.initialized = true;
+  }
+  getPath(sessionId) {
+    return getSessionFilePath(this.directory, this.extension, sessionId);
+  }
+  async getEntries(sessionId) {
+    if (this.useCache && this.cache.has(sessionId)) {
+      return this.cache.get(sessionId);
+    }
+    const entries = await loadEntriesFromDisk(this.getPath(sessionId), sessionId);
+    if (this.useCache) {
+      this.cache.set(sessionId, entries);
+    }
+    return entries;
+  }
+  async create(header) {
+    await this.ensureDir();
+    const filePath = this.getPath(header.id);
+    if (sessionFileExists(filePath)) {
+      throw new Error(`Session already exists: ${header.id}`);
+    }
+    await createSessionFile(filePath, header);
+    if (this.useCache) {
+      this.cache.set(header.id, [header]);
+    }
+  }
+  async append(sessionId, entry) {
+    await this.ensureDir();
+    const filePath = this.getPath(sessionId);
+    if (!sessionFileExists(filePath)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await appendSessionEntry(filePath, entry);
+    if (this.useCache) {
+      this.cache.get(sessionId)?.push(entry);
+    }
+  }
+  async appendBatch(sessionId, entries) {
+    if (entries.length === 0) return;
+    await this.ensureDir();
+    const filePath = this.getPath(sessionId);
+    if (!sessionFileExists(filePath)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await appendSessionEntries(filePath, entries);
+    if (this.useCache) {
+      this.cache.get(sessionId)?.push(...entries);
+    }
+  }
+  async read(sessionId) {
+    await this.ensureDir();
+    return [...await this.getEntries(sessionId)];
+  }
+  async delete(sessionId) {
+    this.cache.delete(sessionId);
+    return deleteSessionFile(this.getPath(sessionId));
+  }
+  async exists(sessionId) {
+    if (this.useCache && this.cache.has(sessionId)) {
+      return true;
+    }
+    return sessionFileExists(this.getPath(sessionId));
+  }
+  async list() {
+    await this.ensureDir();
+    const infos = [];
+    for (const sessionId of await listSessionIds(this.directory, this.extension)) {
+      try {
+        const info = extractSessionInfo(await this.getEntries(sessionId), this.getPath(sessionId));
+        if (info) {
+          infos.push(info);
+        }
+      } catch {
+      }
+    }
+    infos.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return infos;
+  }
+  async clear() {
+    this.cache.clear();
+    await clearSessionFiles(this.directory, this.extension);
+  }
+  flushCache() {
+    this.cache.clear();
+  }
+  async reload(sessionId) {
+    this.cache.delete(sessionId);
+    return this.read(sessionId);
+  }
+  async listIds() {
+    await this.ensureDir();
+    return listSessionIds(this.directory, this.extension);
+  }
+  async getStats(sessionId) {
+    return getSessionFileStats(this.getPath(sessionId));
+  }
+};
+
+// src/storage/paths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { execSync } from "child_process";
+function getDataDir(appName = "cuylabs") {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return join2(homedir(), `.${appName}`);
+  }
+  if (platform === "win32") {
+    return join2(process.env.APPDATA || join2(homedir(), "AppData", "Roaming"), appName);
+  }
+  const xdgData = process.env.XDG_DATA_HOME || join2(homedir(), ".local", "share");
+  return join2(xdgData, appName);
+}
+function getSessionsDir(appName = "cuylabs") {
+  return join2(getDataDir(appName), "sessions");
+}
+function getGitRootHash(cwd) {
+  try {
+    const result = execSync("git rev-list --max-parents=0 --all 2>/dev/null", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const roots = result.split("\n").filter(Boolean).map((s) => s.trim()).sort();
+    return roots[0] || null;
+  } catch {
+    return null;
+  }
+}
+function getProjectId(cwd) {
+  const gitHash = getGitRootHash(cwd);
+  if (gitHash) {
+    return gitHash.slice(0, 12);
+  }
+  return cwd.replace(/^\//, "").replace(/[/\\:]/g, "-").replace(/\s+/g, "-").toLowerCase().slice(-50);
+}
+function getProjectSessionsDir(cwd, appName = "cuylabs") {
+  const projectId = getProjectId(cwd);
+  return join2(getSessionsDir(appName), projectId);
+}
+
+// src/storage/manager/session-manager.ts
+var SessionManager = class {
+  storage;
+  currentSessionId = null;
+  currentLeafId = null;
+  entriesCache = [];
+  idsCache = /* @__PURE__ */ new Set();
+  constructor(storage) {
+    this.storage = storage ?? new MemoryStorage();
+  }
+  async create(options) {
+    const id = options.id ?? crypto.randomUUID();
+    const header = {
+      type: "header",
+      version: STORAGE_VERSION,
+      id,
+      cwd: options.cwd,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      title: options.title,
+      parentSessionId: options.parentSessionId
+    };
+    await this.storage.create(header);
+    this.currentSessionId = id;
+    this.currentLeafId = null;
+    this.entriesCache = [header];
+    this.idsCache.clear();
+    return id;
+  }
+  async load(sessionId) {
+    const entries = await this.storage.read(sessionId);
+    if (entries.length === 0) {
+      throw new Error(`Empty session: ${sessionId}`);
+    }
+    this.currentSessionId = sessionId;
+    this.entriesCache = entries;
+    this.currentLeafId = getLeafId(entries);
+    this.idsCache.clear();
+    for (const entry of entries) {
+      if (entry.type !== "header") {
+        this.idsCache.add(entry.id);
+      }
+    }
+  }
+  getSessionId() {
+    return this.currentSessionId;
+  }
+  getLeafId() {
+    return this.currentLeafId;
+  }
+  async addMessage(message) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    const entry = createMessageEntry(message, this.currentLeafId, this.idsCache);
+    await this.storage.append(this.currentSessionId, entry);
+    this.entriesCache.push(entry);
+    this.idsCache.add(entry.id);
+    this.currentLeafId = entry.id;
+    return entry.id;
+  }
+  async addMessages(messages) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    if (messages.length === 0) {
+      return [];
+    }
+    const entries = [];
+    let parentId = this.currentLeafId;
+    for (const message of messages) {
+      const entry = createMessageEntry(message, parentId, this.idsCache);
+      entries.push(entry);
+      this.idsCache.add(entry.id);
+      parentId = entry.id;
+    }
+    await this.storage.appendBatch(this.currentSessionId, entries);
+    this.entriesCache.push(...entries);
+    this.currentLeafId = entries[entries.length - 1].id;
+    return entries.map((entry) => entry.id);
+  }
+  getMessages(leafId) {
+    return buildMessagesFromEntries(
+      this.entriesCache,
+      leafId ?? this.currentLeafId ?? void 0
+    );
+  }
+  async addCompaction(options) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    const entry = {
+      type: "compaction",
+      id: generateEntryId(this.idsCache),
+      parentId: this.currentLeafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...options
+    };
+    await this.storage.append(this.currentSessionId, entry);
+    this.entriesCache.push(entry);
+    this.idsCache.add(entry.id);
+    this.currentLeafId = entry.id;
+    return entry.id;
+  }
+  async branch(fromEntryId, summary) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    if (!this.idsCache.has(fromEntryId)) {
+      throw new Error(`Entry not found: ${fromEntryId}`);
+    }
+    const entry = {
+      type: "branch",
+      id: generateEntryId(this.idsCache),
+      parentId: fromEntryId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      branchFromId: fromEntryId,
+      summary
+    };
+    await this.storage.append(this.currentSessionId, entry);
+    this.entriesCache.push(entry);
+    this.idsCache.add(entry.id);
+    this.currentLeafId = entry.id;
+    return entry.id;
+  }
+  switchToLeaf(leafId) {
+    if (!this.idsCache.has(leafId)) {
+      throw new Error(`Entry not found: ${leafId}`);
+    }
+    this.currentLeafId = leafId;
+  }
+  async updateMetadata(updates) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    const entry = createMetadataEntry(updates, this.currentLeafId, this.idsCache);
+    await this.storage.append(this.currentSessionId, entry);
+    this.entriesCache.push(entry);
+    this.idsCache.add(entry.id);
+    this.currentLeafId = entry.id;
+  }
+  getContext() {
+    const header = this.entriesCache[0];
+    let title = header.title;
+    let name;
+    for (const entry of this.entriesCache) {
+      if (entry.type === "metadata") {
+        if (entry.title !== void 0) {
+          title = entry.title;
+        }
+        if (entry.name !== void 0) {
+          name = entry.name;
+        }
+      }
+    }
+    return {
+      messages: this.getMessages(),
+      leafId: this.currentLeafId,
+      metadata: {
+        id: header.id,
+        cwd: header.cwd,
+        title,
+        name
+      }
+    };
+  }
+  getEntries() {
+    return [...this.entriesCache];
+  }
+  getHeader() {
+    const header = this.entriesCache[0];
+    return header?.type === "header" ? header : null;
+  }
+  async listSessions() {
+    return this.storage.list();
+  }
+  async deleteSession(sessionId) {
+    const result = await this.storage.delete(sessionId);
+    if (sessionId === this.currentSessionId) {
+      this.currentSessionId = null;
+      this.currentLeafId = null;
+      this.entriesCache = [];
+      this.idsCache.clear();
+    }
+    return result;
+  }
+  async sessionExists(sessionId) {
+    return this.storage.exists(sessionId);
+  }
+  getStorage() {
+    return this.storage;
+  }
+};
+
+// src/storage/manager/default.ts
+var defaultManager = null;
+function getDefaultSessionManager() {
+  if (!defaultManager) {
+    defaultManager = new SessionManager();
+  }
+  return defaultManager;
+}
+function configureDefaultSessionManager(storage) {
+  defaultManager = new SessionManager(storage);
+  return defaultManager;
+}
+
+export {
+  STORAGE_VERSION,
+  generateEntryId,
+  parseJSONL,
+  toJSONL,
+  toJSONLBatch,
+  serializeMessage,
+  deserializeMessage,
+  createMessageEntry,
+  createMetadataEntry,
+  extractSessionInfo,
+  getLeafId,
+  buildEntryPath,
+  buildMessagesFromEntries,
+  MemoryStorage,
+  FileStorage,
+  getDataDir,
+  getSessionsDir,
+  getGitRootHash,
+  getProjectId,
+  getProjectSessionsDir,
+  SessionManager,
+  getDefaultSessionManager,
+  configureDefaultSessionManager
+};