@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-VEKUXUVF.js

@@ -1,41 +0,0 @@
-// src/tracking/file-tracking.ts
-function extractFilePathsFromArgs(args, meta) {
-  if (!meta.pathArgs || meta.pathArgs.length === 0) {
-    return [];
-  }
-  const paths = [];
-  for (const argName of meta.pathArgs) {
-    const value = args[argName];
-    if (typeof value === "string") {
-      paths.push(value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        if (typeof item === "string") {
-          paths.push(item);
-        }
-      }
-    }
-  }
-  return paths;
-}
-function shouldCaptureBaseline(meta) {
-  return meta.operationType !== "read";
-}
-function withFileTracking(tracker, meta, execute) {
-  return (async (...args) => {
-    const params = args[0];
-    if (params && shouldCaptureBaseline(meta)) {
-      const paths = extractFilePathsFromArgs(params, meta);
-      for (const path of paths) {
-        await tracker.beforeWrite(path);
-      }
-    }
-    return await execute(...args);
-  });
-}
-
-export {
-  extractFilePathsFromArgs,
-  shouldCaptureBaseline,
-  withFileTracking
-};

package/dist/chunk-VNQBHPCT.js

@@ -1,398 +0,0 @@
-// src/host/local.ts
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import { existsSync } from "fs";
-import path from "path";
-import process from "process";
-function getShell() {
-  if (process.platform === "win32") {
-    return { shell: "cmd.exe", args: ["/c"] };
-  }
-  const userShell = process.env.SHELL ?? "/bin/bash";
-  return { shell: userShell, args: ["-c"] };
-}
-async function killProcessTree(pid) {
-  try {
-    if (process.platform !== "win32") {
-      process.kill(-pid, "SIGKILL");
-    } else {
-      const { exec: execCb } = await import("child_process");
-      execCb(`taskkill /pid ${pid} /t /f`, () => {
-      });
-    }
-  } catch {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-function localHost(defaultCwd) {
-  const cwd = defaultCwd ?? process.cwd();
-  return {
-    name: "local",
-    // --------------------------------------------------------------------------
-    // File system
-    // --------------------------------------------------------------------------
-    async readFile(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return fs.readFile(abs, "utf-8");
-    },
-    async readBytes(filePath, offset, length) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const fh = await fs.open(abs, "r");
-      try {
-        const buf = Buffer.alloc(length);
-        await fh.read(buf, 0, length, offset);
-        return buf;
-      } finally {
-        await fh.close();
-      }
-    },
-    async writeFile(filePath, content) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      await fs.mkdir(path.dirname(abs), { recursive: true });
-      await fs.writeFile(abs, content, "utf-8");
-    },
-    async exists(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return existsSync(abs);
-    },
-    async stat(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const s = await fs.stat(abs);
-      return {
-        size: s.size,
-        mtime: s.mtime,
-        isDirectory: s.isDirectory(),
-        isFile: s.isFile()
-      };
-    },
-    async readdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      const entries = await fs.readdir(abs, { withFileTypes: true });
-      return entries.map((e) => ({
-        name: e.name,
-        isDirectory: e.isDirectory(),
-        isFile: e.isFile()
-      }));
-    },
-    async mkdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      await fs.mkdir(abs, { recursive: true });
-    },
-    // --------------------------------------------------------------------------
-    // Process execution
-    // --------------------------------------------------------------------------
-    exec(command, options) {
-      const { shell, args } = getShell();
-      const execCwd = options?.cwd ?? cwd;
-      const env = {
-        ...process.env,
-        ...options?.env,
-        // Disable pagers — tools collect output, not interactive
-        PAGER: "cat",
-        GIT_PAGER: "cat"
-      };
-      return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let settled = false;
-        const child = spawn(shell, [...args, command], {
-          cwd: execCwd,
-          detached: process.platform !== "win32",
-          env,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        child.stdout?.on("data", (data) => {
-          stdout += data.toString();
-          options?.onStdout?.(data);
-        });
-        child.stderr?.on("data", (data) => {
-          stderr += data.toString();
-          options?.onStderr?.(data);
-        });
-        let timer;
-        if (options?.timeout && options.timeout > 0) {
-          timer = setTimeout(() => {
-            timedOut = true;
-            if (child.pid) killProcessTree(child.pid);
-          }, options.timeout);
-        }
-        const onAbort = () => {
-          if (child.pid) killProcessTree(child.pid);
-        };
-        options?.signal?.addEventListener("abort", onAbort, { once: true });
-        child.on("close", (code) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          resolve({ stdout, stderr, exitCode: code, timedOut });
-        });
-        child.on("error", (err) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          reject(err);
-        });
-      });
-    }
-  };
-}
-
-// src/host/docker/exec.ts
-async function loadDockerode() {
-  try {
-    const module = await import("dockerode");
-    return module.default ?? module;
-  } catch {
-    throw new Error(
-      "dockerHost requires the 'dockerode' package. Install it with: npm install dockerode"
-    );
-  }
-}
-async function resolveDockerRuntime(options) {
-  const Dockerode = await loadDockerode();
-  if (typeof options.container === "string") {
-    const docker = new Dockerode(options.dockerOptions);
-    const container2 = docker.getContainer(options.container);
-    return {
-      docker,
-      container: container2,
-      label: options.container
-    };
-  }
-  const container = options.container;
-  return {
-    docker: { modem: container.modem },
-    container,
-    label: container.id?.slice(0, 12) ?? "unknown"
-  };
-}
-async function containerExec(runtime, command, options = {}) {
-  const envEntries = options.env ? Object.entries(options.env).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${value}`) : void 0;
-  const exec = await runtime.container.exec({
-    Cmd: ["sh", "-c", command],
-    ...options.user ? { User: options.user } : {},
-    ...options.workdir ? { WorkingDir: options.workdir } : {},
-    ...envEntries && envEntries.length > 0 ? { Env: envEntries } : {},
-    AttachStdout: true,
-    AttachStderr: true
-  });
-  const stream = await exec.start({});
-  let timedOut = false;
-  let aborted = false;
-  return await new Promise((resolve, reject) => {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    runtime.docker.modem.demuxStream(
-      stream,
-      {
-        write: (chunk) => {
-          stdoutChunks.push(chunk);
-          options.onStdout?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      },
-      {
-        write: (chunk) => {
-          stderrChunks.push(chunk);
-          options.onStderr?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      }
-    );
-    let timer;
-    if (options.timeout && options.timeout > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        stream.destroy?.();
-      }, options.timeout);
-    }
-    const onAbort = () => {
-      aborted = true;
-      stream.destroy?.();
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    stream.on("end", async () => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      try {
-        const info = await exec.inspect();
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
-          timedOut
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-    stream.on("error", (error) => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      if (timedOut || aborted) {
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: null,
-          timedOut
-        });
-        return;
-      }
-      reject(error);
-    });
-  });
-}
-async function runDockerCommand(options) {
-  const { runtime, command, defaultUser, defaultWorkdir, execOptions } = options;
-  return await containerExec(runtime, command, {
-    user: defaultUser,
-    workdir: execOptions?.workdir ?? execOptions?.cwd ?? defaultWorkdir,
-    env: execOptions?.env,
-    timeout: execOptions?.timeout,
-    signal: execOptions?.signal,
-    onStdout: execOptions?.onStdout,
-    onStderr: execOptions?.onStderr
-  });
-}
-
-// src/host/docker/shell.ts
-function sq(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function resolveDockerPath(path2, defaultWorkdir) {
-  if (path2.startsWith("/")) {
-    return path2;
-  }
-  const base = defaultWorkdir.endsWith("/") ? defaultWorkdir : `${defaultWorkdir}/`;
-  return `${base}${path2}`;
-}
-
-// src/host/docker/host.ts
-async function dockerHost(options) {
-  const runtime = await resolveDockerRuntime(options);
-  const defaultUser = options.user;
-  const defaultWorkdir = options.workdir ?? "/";
-  async function run(command, execOptions) {
-    return await runDockerCommand({
-      runtime,
-      command,
-      defaultUser,
-      defaultWorkdir,
-      execOptions
-    });
-  }
-  return {
-    name: `docker:${runtime.label}`,
-    async readFile(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`cat ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`readFile failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      return result.stdout;
-    },
-    async readBytes(filePath, offset, length) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `dd if=${sq(absPath)} bs=1 skip=${offset} count=${length} 2>/dev/null`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readBytes failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return Buffer.from(result.stdout, "binary");
-    },
-    async writeFile(filePath, content) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const dir = absPath.substring(0, absPath.lastIndexOf("/")) || "/";
-      await run(`mkdir -p ${sq(dir)}`);
-      const encoded = Buffer.from(content, "utf-8").toString("base64");
-      const result = await run(`echo ${sq(encoded)} | base64 -d > ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `writeFile failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-    },
-    async exists(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`test -e ${sq(absPath)}`);
-      return result.exitCode === 0;
-    },
-    async stat(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `stat -c '%s %Y %F' ${sq(absPath)} 2>/dev/null || stat -f '%z %m %HT' ${sq(absPath)}`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(`stat failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      const parts = result.stdout.trim().split(/\s+/);
-      if (parts.length < 3) {
-        throw new Error(
-          `stat: unexpected output format for ${absPath}: ${result.stdout}`
-        );
-      }
-      const size = parseInt(parts[0], 10);
-      const mtimeSec = parseInt(parts[1], 10);
-      const typeStr = parts.slice(2).join(" ").toLowerCase();
-      return {
-        size,
-        mtime: new Date(mtimeSec * 1e3),
-        isDirectory: typeStr.includes("directory"),
-        isFile: typeStr.includes("regular") || typeStr.includes("file")
-      };
-    },
-    async readdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(
-        `find ${sq(absPath)} -maxdepth 1 -mindepth 1 -printf '%f\\t%y\\n' 2>/dev/null || for f in ${sq(absPath)}/*; do [ -e "$f" ] || continue; n=$(basename "$f"); if [ -d "$f" ]; then printf '%s\\td\\n' "$n"; else printf '%s\\tf\\n' "$n"; fi; done`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readdir failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
-        const [name, type] = line.split("	");
-        return {
-          name,
-          isDirectory: type === "d",
-          isFile: type === "f"
-        };
-      });
-    },
-    async mkdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(`mkdir -p ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`mkdir failed (${absPath}): ${result.stderr.trim()}`);
-      }
-    },
-    async exec(command, execOptions) {
-      return await run(command, execOptions);
-    }
-  };
-}
-
-export {
-  localHost,
-  dockerHost
-};

package/dist/chunk-WWYYNWEW.js

@@ -1,259 +0,0 @@
-// src/context/estimation.ts
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimateMessageTokens(message) {
-  if (typeof message.content === "string") {
-    return estimateTokens(message.content);
-  }
-  if (Array.isArray(message.content)) {
-    let total = 0;
-    for (const part of message.content) {
-      if (typeof part === "string") {
-        total += estimateTokens(part);
-      } else if ("text" in part && typeof part.text === "string") {
-        total += estimateTokens(part.text);
-      } else if ("type" in part && part.type === "image") {
-        total += 765;
-      }
-    }
-    return total;
-  }
-  return 0;
-}
-function estimateConversationTokens(messages) {
-  let total = 0;
-  for (const message of messages) {
-    total += estimateMessageTokens(message);
-    total += 4;
-  }
-  return total;
-}
-
-// src/agent/types/compaction.ts
-var PRUNE_PROTECTED_TOOLS = ["skill"];
-
-// src/context/pruning.ts
-var DEFAULT_CONTEXT_LIMITS = {
-  contextWindow: 128e3,
-  reserveTokens: 16e3,
-  // Reserve for output
-  protectedTokens: 4e4,
-  // Keep recent 40 k tokens
-  pruneMinimum: 2e4
-  // Don't prune until 20 k tokens
-};
-function isContextOverflowing(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
-  const threshold = limits.contextWindow - limits.reserveTokens;
-  return tokens > threshold;
-}
-function shouldPruneContext(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
-  if (tokens < limits.pruneMinimum) return false;
-  return isContextOverflowing(tokens, limits);
-}
-function findCutPoint(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens) {
-  if (messages.length === 0) return 0;
-  let tokensFromEnd = 0;
-  let cutIndex = messages.length;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    tokensFromEnd += estimateMessageTokens(messages[i]);
-    if (tokensFromEnd >= protectedTokens) {
-      cutIndex = i;
-      break;
-    }
-  }
-  if (cutIndex <= 1) return 0;
-  const startIndex = cutIndex >= messages.length ? messages.length - 1 : cutIndex;
-  for (let i = startIndex; i >= 1; i--) {
-    const msg = messages[i];
-    const prevMsg = messages[i - 1];
-    if (!msg || !prevMsg) continue;
-    if (msg.role === "tool") continue;
-    if (prevMsg.role === "assistant" || prevMsg.role === "user") {
-      return i;
-    }
-  }
-  return 0;
-}
-function pruneToolResults(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options) {
-  const protectedToolSet = /* @__PURE__ */ new Set([
-    ...PRUNE_PROTECTED_TOOLS,
-    ...options?.protectedTools ?? []
-  ]);
-  let tokensFromEnd = 0;
-  const tokenPositions = [];
-  for (let i = messages.length - 1; i >= 0; i--) {
-    tokensFromEnd += estimateMessageTokens(messages[i]);
-    tokenPositions[i] = tokensFromEnd;
-  }
-  return messages.map((msg, i) => {
-    if (tokenPositions[i] < protectedTokens) return msg;
-    if (!("role" in msg) || msg.role !== "tool") return msg;
-    const toolMsg = msg;
-    if ("compactedAt" in toolMsg && toolMsg.compactedAt) return msg;
-    if (toolMsg.toolName && protectedToolSet.has(toolMsg.toolName)) return msg;
-    const currentTokens = estimateTokens(toolMsg.content);
-    if (currentTokens < 500) return msg;
-    return {
-      ...toolMsg,
-      content: `[Output pruned - was ${currentTokens} tokens]`,
-      compactedAt: Date.now()
-    };
-  });
-}
-
-// src/context/summarization.ts
-import { generateText } from "ai";
-var DEFAULT_SUMMARY_PROMPT = `You are summarizing a conversation to continue it with context.
-
-Create a structured summary that captures:
-1. **Goal**: What the user is trying to accomplish
-2. **Progress**: What has been done so far
-3. **Decisions**: Key decisions made during the conversation
-4. **Current State**: Where we left off
-5. **Next Steps**: What should happen next
-
-Be concise but comprehensive. Include specific file paths, function names, and technical details that would be lost otherwise.
-
-Format as a clear summary that could be given to another assistant to continue the work.`;
-async function generateSummary(messages, options) {
-  const conversationText = messages.map((m) => {
-    const role = m.role.toUpperCase();
-    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-    return `[${role}]: ${content}`;
-  }).join("\n\n");
-  const prompt = options.customPrompt || DEFAULT_SUMMARY_PROMPT;
-  const { text } = await generateText({
-    model: options.model,
-    maxOutputTokens: options.maxTokens ?? 2e3,
-    system: prompt,
-    prompt: `Summarize this conversation:
-
-${conversationText}`
-  });
-  return text;
-}
-async function pruneContext(messages, options = {}) {
-  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
-  let currentMessages = [...messages];
-  let tokensRemoved = 0;
-  let removedCount = 0;
-  let summarized = false;
-  let summary;
-  const initialTokens = estimateConversationTokens(currentMessages);
-  if (!shouldPruneContext(initialTokens, limits)) {
-    return { messages: currentMessages, removedCount: 0, tokensRemoved: 0, summarized: false };
-  }
-  const prunedMessages = pruneToolResults(currentMessages, limits.protectedTokens);
-  const afterPruneTokens = estimateConversationTokens(prunedMessages);
-  tokensRemoved = initialTokens - afterPruneTokens;
-  currentMessages = prunedMessages;
-  if (!isContextOverflowing(afterPruneTokens, limits)) {
-    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
-  }
-  const cutIndex = findCutPoint(currentMessages, limits.protectedTokens);
-  if (cutIndex === 0) {
-    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
-  }
-  const toSummarize = currentMessages.slice(0, cutIndex);
-  const toKeep = currentMessages.slice(cutIndex);
-  removedCount = toSummarize.length;
-  tokensRemoved += estimateConversationTokens(toSummarize);
-  if (options.model) {
-    summary = await generateSummary(toSummarize, {
-      model: options.model,
-      customPrompt: options.summaryPrompt
-    });
-    summarized = true;
-    const summaryMessage = {
-      id: crypto.randomUUID(),
-      role: "system",
-      content: `## Previous Conversation Summary
-
-${summary}`,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    currentMessages = [summaryMessage, ...toKeep];
-  } else {
-    currentMessages = toKeep;
-  }
-  return { messages: currentMessages, removedCount, tokensRemoved, summarized, summary };
-}
-
-// src/context/manager.ts
-var ContextManager = class {
-  limits;
-  model;
-  summaryPrompt;
-  constructor(options) {
-    this.limits = { ...DEFAULT_CONTEXT_LIMITS, ...options?.limits };
-    this.model = options?.model;
-    this.summaryPrompt = options?.summaryPrompt;
-  }
-  /** Get a copy of the current context limits. */
-  getLimits() {
-    return { ...this.limits };
-  }
-  /** Update context limits (e.g. when switching models). */
-  setLimits(limits) {
-    this.limits = { ...this.limits, ...limits };
-  }
-  /** Set the model used for summarisation. */
-  setModel(model) {
-    this.model = model;
-  }
-  /** Estimate total tokens for a message array. */
-  estimateTokens(messages) {
-    return estimateConversationTokens(messages);
-  }
-  /** Check whether the context is overflowing. */
-  isOverflowing(messages) {
-    const tokens = this.estimateTokens(messages);
-    return isContextOverflowing(tokens, this.limits);
-  }
-  /** Check whether pruning should be triggered. */
-  shouldPrune(messages) {
-    const tokens = this.estimateTokens(messages);
-    return shouldPruneContext(tokens, this.limits);
-  }
-  /** Prune context to fit within limits. */
-  async prune(messages) {
-    return pruneContext(messages, {
-      model: this.model,
-      limits: this.limits,
-      summaryPrompt: this.summaryPrompt
-    });
-  }
-  /**
-   * Get a snapshot of token statistics.
-   *
-   * Useful for dashboards, logging, or deciding whether to prune.
-   */
-  getStats(messages) {
-    const tokens = this.estimateTokens(messages);
-    const limit = this.limits.contextWindow - this.limits.reserveTokens;
-    return {
-      tokens,
-      limit,
-      available: Math.max(0, limit - tokens),
-      utilizationPercent: Math.round(tokens / limit * 100),
-      isOverflowing: isContextOverflowing(tokens, this.limits),
-      shouldPrune: shouldPruneContext(tokens, this.limits)
-    };
-  }
-};
-
-export {
-  estimateTokens,
-  estimateMessageTokens,
-  estimateConversationTokens,
-  PRUNE_PROTECTED_TOOLS,
-  DEFAULT_CONTEXT_LIMITS,
-  isContextOverflowing,
-  shouldPruneContext,
-  findCutPoint,
-  pruneToolResults,
-  generateSummary,
-  pruneContext,
-  ContextManager
-};