@cuylabs/agent-core 0.4.0 → 0.6.0

package/dist/chunk-VBWWUHWI.js

@@ -0,0 +1,724 @@
+// src/tracking/checkpoint/manager.ts
+import { rm, unlink } from "fs/promises";
+import { join as join2, relative, resolve } from "path";
+
+// src/tracking/checkpoint/git.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { access, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+async function runCheckpointGitCommand(gitDir, workTree, args) {
+  return await new Promise((resolve3) => {
+    const fullArgs = ["--git-dir", gitDir, "--work-tree", workTree, ...args];
+    const proc = spawn("git", fullArgs, {
+      cwd: workTree,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_ASKPASS: "true"
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve3({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 0
+      });
+    });
+    proc.on("error", (error) => {
+      resolve3({
+        stdout: "",
+        stderr: error.message,
+        exitCode: 1
+      });
+    });
+  });
+}
+function getCheckpointProjectId(workDir) {
+  return createHash("sha256").update(workDir).digest("hex").slice(0, 16);
+}
+function getDefaultCheckpointStorageDir(workDir) {
+  return join(homedir(), ".cuylabs", "checkpoints", getCheckpointProjectId(workDir));
+}
+async function initializeCheckpointRepository(gitDir, workDir) {
+  await mkdir(gitDir, { recursive: true });
+  const headPath = join(gitDir, "HEAD");
+  let needsInit = false;
+  try {
+    await access(headPath);
+  } catch {
+    needsInit = true;
+  }
+  if (!needsInit) {
+    return;
+  }
+  const initResult = await new Promise(
+    (resolve3) => {
+      const proc = spawn("git", ["init", "--bare"], {
+        cwd: gitDir,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stderr = "";
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        resolve3({ exitCode: code ?? 0, stderr });
+      });
+      proc.on("error", (error) => {
+        resolve3({ exitCode: 1, stderr: error.message });
+      });
+    }
+  );
+  if (initResult.exitCode !== 0) {
+    throw new Error(`Failed to init checkpoint repo: ${initResult.stderr}`);
+  }
+  await runCheckpointGitCommand(gitDir, workDir, ["config", "gc.auto", "0"]);
+  await runCheckpointGitCommand(gitDir, workDir, [
+    "config",
+    "core.autocrlf",
+    "false"
+  ]);
+}
+
+// src/tracking/checkpoint/log.ts
+import { dirname } from "path";
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+async function readCheckpointLog(logPath) {
+  try {
+    const content = await readFile(logPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    return lines.map((line) => {
+      const entry = JSON.parse(line);
+      return {
+        ...entry,
+        createdAt: new Date(entry.createdAt)
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function appendCheckpointLog(logPath, checkpoint) {
+  const line = `${JSON.stringify({
+    ...checkpoint,
+    createdAt: checkpoint.createdAt.toISOString()
+  })}
+`;
+  await mkdir2(dirname(logPath), { recursive: true });
+  try {
+    const existing = await readFile(logPath, "utf-8");
+    await writeFile(logPath, `${existing}${line}`);
+  } catch {
+    await writeFile(logPath, line);
+  }
+}
+async function removeCheckpointFromLog(logPath, checkpointId) {
+  try {
+    const content = await readFile(logPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const filtered = lines.filter((line) => {
+      const entry = JSON.parse(line);
+      return entry.id !== checkpointId;
+    });
+    await writeFile(
+      logPath,
+      filtered.join("\n") + (filtered.length > 0 ? "\n" : "")
+    );
+  } catch {
+  }
+}
+
+// src/tracking/checkpoint/manager.ts
+function classifyChangeType(status) {
+  switch (status?.charAt(0)) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    default:
+      return "modified";
+  }
+}
+async function createCheckpointManager(config) {
+  const workDir = resolve(config.workDir);
+  const storageDir = config.storageDir ?? getDefaultCheckpointStorageDir(workDir);
+  const gitDir = join2(storageDir, "git");
+  const logPath = join2(storageDir, "checkpoints.jsonl");
+  const state = {
+    config: {
+      workDir,
+      storageDir,
+      trackContent: config.trackContent ?? true,
+      exclude: config.exclude ?? [],
+      maxCheckpoints: config.maxCheckpoints ?? 100
+    },
+    gitDir,
+    initialized: false,
+    checkpointLog: []
+  };
+  async function initialize() {
+    if (state.initialized) {
+      return;
+    }
+    await initializeCheckpointRepository(gitDir, workDir);
+    state.checkpointLog = await readCheckpointLog(logPath);
+    state.initialized = true;
+  }
+  await initialize();
+  const manager = {
+    async save(label = "checkpoint", metadata) {
+      await initialize();
+      const addResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "add",
+        "--all",
+        "."
+      ]);
+      if (addResult.exitCode !== 0) {
+        throw new Error(`Failed to stage files: ${addResult.stderr}`);
+      }
+      const treeResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "write-tree"
+      ]);
+      if (treeResult.exitCode !== 0) {
+        throw new Error(`Failed to write tree: ${treeResult.stderr}`);
+      }
+      const id = treeResult.stdout.trim();
+      const existing = state.checkpointLog.find((checkpoint2) => checkpoint2.id === id);
+      if (existing) {
+        return existing;
+      }
+      const checkpoint = {
+        id,
+        label,
+        createdAt: /* @__PURE__ */ new Date(),
+        metadata
+      };
+      await appendCheckpointLog(logPath, checkpoint);
+      state.checkpointLog.push(checkpoint);
+      if (state.checkpointLog.length > state.config.maxCheckpoints) {
+        await manager.prune();
+      }
+      return checkpoint;
+    },
+    async restore(checkpointId) {
+      await initialize();
+      const readTreeResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "read-tree",
+        checkpointId
+      ]);
+      if (readTreeResult.exitCode !== 0) {
+        throw new Error(`Failed to read checkpoint: ${readTreeResult.stderr}`);
+      }
+      const checkoutResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "checkout-index",
+        "-a",
+        "-f"
+      ]);
+      if (checkoutResult.exitCode !== 0) {
+        throw new Error(`Failed to restore files: ${checkoutResult.stderr}`);
+      }
+      const changes = await manager.changes(checkpointId);
+      for (const change of changes.files) {
+        if (change.type === "added") {
+          try {
+            await unlink(join2(workDir, change.path));
+          } catch {
+          }
+        }
+      }
+    },
+    async changes(checkpointId) {
+      await initialize();
+      await runCheckpointGitCommand(gitDir, workDir, ["add", "--all", "."]);
+      const diffStatResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "diff",
+        "--name-status",
+        checkpointId
+      ]);
+      const files = [];
+      if (diffStatResult.exitCode === 0 && diffStatResult.stdout) {
+        for (const line of diffStatResult.stdout.split("\n")) {
+          if (!line.trim()) {
+            continue;
+          }
+          const [status, ...pathParts] = line.split("	");
+          files.push({
+            path: pathParts.join("	"),
+            type: classifyChangeType(status)
+          });
+        }
+      }
+      const diffResult = await runCheckpointGitCommand(gitDir, workDir, [
+        "diff",
+        "--no-ext-diff",
+        checkpointId,
+        "--"
+      ]);
+      return {
+        fromCheckpoint: checkpointId,
+        files,
+        diff: diffResult.stdout
+      };
+    },
+    async undoFiles(checkpointId, files) {
+      await initialize();
+      for (const file of files) {
+        const relativePath = relative(workDir, resolve(workDir, file));
+        const result = await runCheckpointGitCommand(gitDir, workDir, [
+          "checkout",
+          checkpointId,
+          "--",
+          relativePath
+        ]);
+        if (result.exitCode === 0) {
+          continue;
+        }
+        const lsResult = await runCheckpointGitCommand(gitDir, workDir, [
+          "ls-tree",
+          checkpointId,
+          "--",
+          relativePath
+        ]);
+        if (!lsResult.stdout.trim()) {
+          try {
+            await unlink(join2(workDir, relativePath));
+          } catch {
+          }
+        }
+      }
+    },
+    async list() {
+      return [...state.checkpointLog].reverse();
+    },
+    async remove(checkpointId) {
+      await removeCheckpointFromLog(logPath, checkpointId);
+      state.checkpointLog = state.checkpointLog.filter(
+        (checkpoint) => checkpoint.id !== checkpointId
+      );
+    },
+    async prune() {
+      const toRemove = state.checkpointLog.length - state.config.maxCheckpoints;
+      if (toRemove <= 0) {
+        return 0;
+      }
+      const removeIds = state.checkpointLog.slice(0, toRemove).map((checkpoint) => checkpoint.id);
+      for (const checkpointId of removeIds) {
+        await removeCheckpointFromLog(logPath, checkpointId);
+      }
+      state.checkpointLog = state.checkpointLog.slice(toRemove);
+      await runCheckpointGitCommand(gitDir, workDir, ["gc", "--prune=now"]);
+      return removeIds.length;
+    },
+    async latest() {
+      return state.checkpointLog[state.checkpointLog.length - 1] ?? null;
+    },
+    async getFileAt(checkpointId, filePath) {
+      await initialize();
+      const relativePath = relative(workDir, resolve(workDir, filePath));
+      const result = await runCheckpointGitCommand(gitDir, workDir, [
+        "show",
+        `${checkpointId}:${relativePath}`
+      ]);
+      return result.exitCode === 0 ? result.stdout : null;
+    },
+    isInitialized() {
+      return state.initialized;
+    },
+    async close() {
+      state.initialized = false;
+    }
+  };
+  return manager;
+}
+async function clearCheckpoints(workDir) {
+  const storageDir = getDefaultCheckpointStorageDir(workDir);
+  try {
+    await rm(storageDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/tracking/turn-tracker/tracker.ts
+import { spawn as spawn2 } from "child_process";
+import { normalize, relative as relative3, resolve as resolve2 } from "path";
+
+// src/tracking/turn-tracker/diff.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile2, stat, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, relative as relative2 } from "path";
+async function captureTurnFileBaseline(absPath) {
+  try {
+    const content = await readFile2(absPath, "utf-8");
+    const stats = await stat(absPath);
+    return {
+      path: absPath,
+      content,
+      mode: stats.mode,
+      hash: hashTurnTrackerContent(content),
+      capturedAt: /* @__PURE__ */ new Date()
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        path: absPath,
+        content: null,
+        mode: null,
+        hash: null,
+        capturedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    throw error;
+  }
+}
+async function restoreTurnTrackedFile(absPath, baseline) {
+  if (baseline.content === null) {
+    try {
+      await unlink2(absPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    return;
+  }
+  await mkdir3(dirname2(absPath), { recursive: true });
+  await writeFile2(absPath, baseline.content, {
+    mode: baseline.mode ?? void 0
+  });
+}
+async function computeTurnTrackerFileChange(options) {
+  const { cwd, absPath, baseline, preferGitDiff, canUseGitDiff } = options;
+  const relPath = relative2(cwd, absPath);
+  const currentContent = await readTrackedFileContent(absPath);
+  let type;
+  if (baseline.content === null && currentContent === null) {
+    type = "unchanged";
+  } else if (baseline.content === null && currentContent !== null) {
+    type = "created";
+  } else if (baseline.content !== null && currentContent === null) {
+    type = "deleted";
+  } else if (baseline.content === currentContent) {
+    type = "unchanged";
+  } else {
+    type = "modified";
+  }
+  if (type === "unchanged") {
+    return { path: relPath, type, additions: 0, deletions: 0 };
+  }
+  const diff = await generateTurnTrackerDiff({
+    relPath,
+    oldContent: baseline.content,
+    newContent: currentContent,
+    preferGitDiff,
+    canUseGitDiff
+  });
+  const { additions, deletions } = countUnifiedDiffStats(diff);
+  return {
+    path: relPath,
+    type,
+    additions,
+    deletions,
+    diff
+  };
+}
+async function readTrackedFileContent(absPath) {
+  try {
+    return await readFile2(absPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function generateTurnTrackerDiff(options) {
+  const { relPath, oldContent, newContent, preferGitDiff, canUseGitDiff } = options;
+  const oldLines = (oldContent ?? "").split("\n");
+  const newLines = (newContent ?? "").split("\n");
+  if (preferGitDiff && canUseGitDiff) {
+    const gitDiff = await createGitStyleDiffPlaceholder();
+    if (gitDiff) {
+      return gitDiff;
+    }
+  }
+  return buildSimpleUnifiedDiff({
+    path: relPath,
+    oldLines,
+    newLines,
+    wasCreated: oldContent === null,
+    wasDeleted: newContent === null
+  });
+}
+function buildSimpleUnifiedDiff(options) {
+  const { path, oldLines, newLines, wasCreated, wasDeleted } = options;
+  const header = [
+    `--- a/${path}${wasCreated ? " (new file)" : ""}`,
+    `+++ b/${path}${wasDeleted ? " (deleted)" : ""}`
+  ];
+  const hunks = [];
+  if (wasCreated) {
+    hunks.push(`@@ -0,0 +1,${newLines.length} @@`);
+    for (const line of newLines) {
+      hunks.push(`+${line}`);
+    }
+  } else if (wasDeleted) {
+    hunks.push(`@@ -1,${oldLines.length} +0,0 @@`);
+    for (const line of oldLines) {
+      hunks.push(`-${line}`);
+    }
+  } else {
+    hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
+    for (const line of oldLines) {
+      hunks.push(`-${line}`);
+    }
+    for (const line of newLines) {
+      hunks.push(`+${line}`);
+    }
+  }
+  return [...header, ...hunks].join("\n");
+}
+function countUnifiedDiffStats(diff) {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      additions++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      deletions++;
+    }
+  }
+  return { additions, deletions };
+}
+function hashTurnTrackerContent(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function createGitStyleDiffPlaceholder() {
+  return null;
+}
+
+// src/tracking/turn-tracker/tracker.ts
+var TurnChangeTracker = class {
+  config;
+  currentTurn = null;
+  gitDetected = null;
+  constructor(config) {
+    this.config = {
+      cwd: resolve2(config.cwd),
+      useGit: config.useGit ?? true,
+      maxTrackedFiles: config.maxTrackedFiles ?? 100
+    };
+  }
+  startTurn(turnId) {
+    if (this.currentTurn && !this.currentTurn.completed) {
+      this.currentTurn.completed = true;
+    }
+    this.currentTurn = {
+      id: turnId,
+      startedAt: /* @__PURE__ */ new Date(),
+      baselines: /* @__PURE__ */ new Map(),
+      completed: false
+    };
+  }
+  async endTurn() {
+    if (!this.currentTurn) {
+      return {
+        turnId: "",
+        files: [],
+        totalTracked: 0,
+        additions: 0,
+        deletions: 0,
+        diff: null,
+        duration: 0
+      };
+    }
+    const turn = this.currentTurn;
+    turn.completed = true;
+    const files = [];
+    let additions = 0;
+    let deletions = 0;
+    const diffs = [];
+    for (const [absPath, baseline] of turn.baselines) {
+      const change = await this.computeFileChange(absPath, baseline);
+      files.push(change);
+      additions += change.additions;
+      deletions += change.deletions;
+      if (change.diff) {
+        diffs.push(change.diff);
+      }
+    }
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    return {
+      turnId: turn.id,
+      files,
+      totalTracked: turn.baselines.size,
+      additions,
+      deletions,
+      diff: diffs.length > 0 ? diffs.join("\n") : null,
+      duration: Date.now() - turn.startedAt.getTime()
+    };
+  }
+  isInTurn() {
+    return this.currentTurn !== null && !this.currentTurn.completed;
+  }
+  getCurrentTurnId() {
+    return this.currentTurn?.id ?? null;
+  }
+  async beforeWrite(filePath) {
+    if (!this.currentTurn || this.currentTurn.completed) {
+      return false;
+    }
+    const absPath = resolve2(this.config.cwd, filePath);
+    const normalizedPath = normalize(absPath);
+    if (this.currentTurn.baselines.has(normalizedPath)) {
+      return false;
+    }
+    if (this.currentTurn.baselines.size >= this.config.maxTrackedFiles) {
+      console.warn(
+        `[TurnTracker] Max tracked files (${this.config.maxTrackedFiles}) reached, skipping: ${filePath}`
+      );
+      return false;
+    }
+    const baseline = await captureTurnFileBaseline(normalizedPath);
+    this.currentTurn.baselines.set(normalizedPath, baseline);
+    return true;
+  }
+  getTrackedFiles() {
+    if (!this.currentTurn) {
+      return [];
+    }
+    return Array.from(this.currentTurn.baselines.keys()).map(
+      (path) => relative3(this.config.cwd, path)
+    );
+  }
+  isTracking(filePath) {
+    if (!this.currentTurn) {
+      return false;
+    }
+    const absPath = resolve2(this.config.cwd, filePath);
+    return this.currentTurn.baselines.has(normalize(absPath));
+  }
+  async getDiff() {
+    if (!this.currentTurn || this.currentTurn.baselines.size === 0) {
+      return null;
+    }
+    const diffs = [];
+    for (const [absPath, baseline] of this.currentTurn.baselines) {
+      const change = await this.computeFileChange(absPath, baseline);
+      if (change.diff) {
+        diffs.push(change.diff);
+      }
+    }
+    return diffs.length > 0 ? diffs.join("\n") : null;
+  }
+  async getFileDiff(filePath) {
+    if (!this.currentTurn) {
+      return null;
+    }
+    const absPath = resolve2(this.config.cwd, filePath);
+    const baseline = this.currentTurn.baselines.get(normalize(absPath));
+    if (!baseline) {
+      return null;
+    }
+    const change = await this.computeFileChange(absPath, baseline);
+    return change.diff ?? null;
+  }
+  async undoTurn() {
+    if (!this.currentTurn) {
+      return { restored: [], failed: [] };
+    }
+    const result = { restored: [], failed: [] };
+    for (const [absPath, baseline] of this.currentTurn.baselines) {
+      const relPath = relative3(this.config.cwd, absPath);
+      try {
+        await restoreTurnTrackedFile(absPath, baseline);
+        result.restored.push(relPath);
+      } catch (error) {
+        result.failed.push({
+          path: relPath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async undoFiles(filePaths) {
+    if (!this.currentTurn) {
+      return { restored: [], failed: [] };
+    }
+    const result = { restored: [], failed: [] };
+    for (const filePath of filePaths) {
+      const absPath = resolve2(this.config.cwd, filePath);
+      const normalizedPath = normalize(absPath);
+      const baseline = this.currentTurn.baselines.get(normalizedPath);
+      if (!baseline) {
+        result.failed.push({
+          path: filePath,
+          reason: "File not tracked in current turn"
+        });
+        continue;
+      }
+      try {
+        await restoreTurnTrackedFile(absPath, baseline);
+        result.restored.push(filePath);
+      } catch (error) {
+        result.failed.push({
+          path: filePath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async computeFileChange(absPath, baseline) {
+    return await computeTurnTrackerFileChange({
+      cwd: this.config.cwd,
+      absPath,
+      baseline,
+      preferGitDiff: this.config.useGit,
+      canUseGitDiff: await this.isInGitRepo()
+    });
+  }
+  async isInGitRepo() {
+    if (!this.config.useGit) {
+      return false;
+    }
+    if (this.gitDetected !== null) {
+      return this.gitDetected;
+    }
+    return await new Promise((resolvePromise) => {
+      const proc = spawn2("git", ["rev-parse", "--git-dir"], {
+        cwd: this.config.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      proc.on("close", (code) => {
+        this.gitDetected = code === 0;
+        resolvePromise(this.gitDetected);
+      });
+      proc.on("error", () => {
+        this.gitDetected = false;
+        resolvePromise(false);
+      });
+    });
+  }
+};
+function createTurnTracker(config) {
+  return new TurnChangeTracker(config);
+}
+
+export {
+  TurnChangeTracker,
+  createTurnTracker,
+  createCheckpointManager,
+  clearCheckpoints
+};