agentel 0.2.0

package/src/importers/cline.js

@@ -0,0 +1,471 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const DEFAULT_MAX_DEPTH = 6;
+const DEFAULT_MAX_FILES = 500;
+const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const DEFAULT_GIT_COMMITS = 25;
+
+function readClineCheckpointDiffs(taskDir, options = {}) {
+  const artifacts = discoverClineCheckpointArtifacts(taskDir, options);
+  const toolCalls = artifacts.map((artifact) => clineCheckpointToolCall(artifact)).filter(Boolean);
+  const messages = toolCalls.map((toolCall, index) => clineCheckpointMessage(toolCall, artifacts[index]));
+  return {
+    artifacts,
+    toolCalls,
+    messages,
+    sourceFiles: uniqueSorted(artifacts.flatMap((artifact) => artifact.sourceFiles || []))
+  };
+}
+
+function discoverClineCheckpointArtifacts(taskDir, options = {}) {
+  const roots = clineCheckpointRoots(taskDir);
+  const artifacts = [];
+  const seen = new Set();
+  for (const root of roots) {
+    for (const repo of findGitRepos(root, options)) {
+      for (const artifact of gitCheckpointArtifacts(repo, options)) {
+        pushUniqueArtifact(artifacts, seen, artifact);
+      }
+    }
+    for (const file of checkpointCandidateFiles(root, options)) {
+      for (const artifact of fileCheckpointArtifacts(file, taskDir, options)) {
+        pushUniqueArtifact(artifacts, seen, artifact);
+      }
+    }
+  }
+  return artifacts.sort((a, b) => String(a.timestamp || "").localeCompare(String(b.timestamp || "")) || String(a.sourcePath || "").localeCompare(String(b.sourcePath || "")));
+}
+
+function clineCheckpointRoots(taskDir) {
+  if (!taskDir || !safeStat(taskDir)?.isDirectory()) return [];
+  return uniqueSorted([
+    path.join(taskDir, "checkpoints"),
+    path.join(taskDir, "checkpoint"),
+    path.join(taskDir, "checkpointStore"),
+    path.join(taskDir, "checkpoint_store"),
+    path.join(taskDir, ".checkpoints")
+  ].filter((dir) => safeStat(dir)?.isDirectory()));
+}
+
+function checkpointCandidateFiles(root, options = {}) {
+  const files = [];
+  const maxFiles = positiveInteger(options.maxFiles, DEFAULT_MAX_FILES);
+  walkLimited(root, {
+    maxDepth: positiveInteger(options.maxDepth, DEFAULT_MAX_DEPTH),
+    skipDirs: new Set([".git", "node_modules", "vendor", "dist", "build"]),
+    visitFile(file) {
+      if (files.length >= maxFiles) return;
+      if (isCheckpointArtifactFile(file)) files.push(file);
+    }
+  });
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+function findGitRepos(root, options = {}) {
+  const repos = [];
+  const maxFiles = positiveInteger(options.maxFiles, DEFAULT_MAX_FILES);
+  walkLimited(root, {
+    maxDepth: positiveInteger(options.maxDepth, DEFAULT_MAX_DEPTH),
+    skipDirs: new Set(["node_modules", "vendor", "dist", "build"]),
+    visitDir(dir, entryNames) {
+      if (repos.length >= maxFiles) return false;
+      if (entryNames.includes(".git") && safeStat(path.join(dir, ".git"))?.isDirectory()) {
+        repos.push(dir);
+        return false;
+      }
+      return true;
+    }
+  });
+  return repos.sort((a, b) => a.localeCompare(b));
+}
+
+function isCheckpointArtifactFile(file) {
+  const name = path.basename(file).toLowerCase();
+  if (/\.(diff|patch)$/i.test(name)) return true;
+  if (/\.(json|jsonl)$/i.test(name)) return true;
+  return /diff|patch|change|edit|checkpoint/i.test(name) && /\.(txt|md)$/i.test(name);
+}
+
+function fileCheckpointArtifacts(file, taskDir, options = {}) {
+  const stat = safeStat(file);
+  if (!stat || stat.size > positiveInteger(options.maxFileBytes, DEFAULT_MAX_FILE_BYTES)) return [];
+  const text = readUtf8(file);
+  if (!text.trim()) return [];
+  const timestamp = stat.mtimeMs ? new Date(stat.mtimeMs).toISOString() : undefined;
+  if (/\.(diff|patch)$/i.test(file) || looksLikeUnifiedDiff(text) || looksLikeClineSearchReplace(text)) {
+    return [checkpointArtifact({
+      kind: "diff-file",
+      checkpointId: checkpointIdFromPath(file, taskDir),
+      diff: text.trim(),
+      timestamp,
+      sourcePath: file,
+      sourceFiles: [file]
+    })];
+  }
+  if (/\.jsonl$/i.test(file)) return jsonlCheckpointArtifacts(file, text, timestamp, taskDir);
+  if (/\.json$/i.test(file)) return jsonCheckpointArtifacts(file, text, timestamp, taskDir);
+  return [];
+}
+
+function jsonlCheckpointArtifacts(file, text, timestamp, taskDir) {
+  const artifacts = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const data = parseJson(line);
+    if (data) artifacts.push(...jsonNodeCheckpointArtifacts(data, { file, timestamp, taskDir }));
+  }
+  return artifacts;
+}
+
+function jsonCheckpointArtifacts(file, text, timestamp, taskDir) {
+  const data = parseJson(text);
+  if (!data) return [];
+  return jsonNodeCheckpointArtifacts(data, { file, timestamp, taskDir });
+}
+
+function jsonNodeCheckpointArtifacts(node, context, trail = []) {
+  if (node == null) return [];
+  if (Array.isArray(node)) return node.flatMap((item, index) => jsonNodeCheckpointArtifacts(item, context, trail.concat(String(index))));
+  if (typeof node !== "object") return [];
+
+  const nextContext = jsonNodeContext(node, context);
+  const artifacts = [];
+  const direct = directJsonCheckpointArtifact(node, nextContext, trail);
+  if (direct) artifacts.push(direct);
+
+  for (const [key, value] of Object.entries(node)) {
+    if (!value || typeof value !== "object") continue;
+    if (isLikelyCheckpointContainerKey(key) || isLikelyEditContainerKey(key)) {
+      artifacts.push(...jsonNodeCheckpointArtifacts(value, nextContext, trail.concat(key)));
+    }
+  }
+  return artifacts;
+}
+
+function jsonNodeContext(node, context) {
+  return {
+    ...context,
+    checkpointId: firstString(node.checkpointId, node.checkpoint_id, node.id, context.checkpointId),
+    timestamp: toIso(firstString(node.timestamp, node.createdAt, node.created_at, node.ts)) || context.timestamp,
+    path: firstString(node.path, node.file, node.filePath, node.file_path, node.filename, node.relativePath, node.relative_path, context.path)
+  };
+}
+
+function directJsonCheckpointArtifact(node, context, trail) {
+  const diff = firstString(
+    node.diff,
+    node.patch,
+    node.unifiedDiff,
+    node.unified_diff,
+    looksLikeUnifiedDiff(node.content) || looksLikeClineSearchReplace(node.content) ? node.content : "",
+    looksLikeUnifiedDiff(node.text) || looksLikeClineSearchReplace(node.text) ? node.text : ""
+  );
+  const pathValue = firstString(node.path, node.file, node.filePath, node.file_path, node.filename, node.relativePath, node.relative_path, context.path);
+  if (diff) {
+    return checkpointArtifact({
+      kind: "metadata-diff",
+      checkpointId: firstString(context.checkpointId, checkpointIdFromPath(context.file, context.taskDir)),
+      path: pathValue || undefined,
+      diff: normalizeDiffText(diff, pathValue),
+      timestamp: context.timestamp,
+      sourcePath: context.file,
+      sourceFiles: [context.file],
+      rawPath: trail.join(".") || undefined
+    });
+  }
+
+  const oldString = firstString(node.old_string, node.oldString, node.oldText, node.previousText, node.beforeText, node.previous, node.before, node.search);
+  const newString = firstString(node.new_string, node.newString, node.newText, node.currentText, node.afterText, node.current, node.after, node.replace);
+  if ((oldString || newString) && (pathValue || oldString || newString)) {
+    return checkpointArtifact({
+      kind: "metadata-edit",
+      checkpointId: firstString(context.checkpointId, checkpointIdFromPath(context.file, context.taskDir)),
+      path: pathValue || undefined,
+      old_string: oldString,
+      new_string: newString,
+      timestamp: context.timestamp,
+      sourcePath: context.file,
+      sourceFiles: [context.file],
+      rawPath: trail.join(".") || undefined
+    });
+  }
+  return null;
+}
+
+function gitCheckpointArtifacts(repoDir, options = {}) {
+  const commits = gitCheckpointCommits(repoDir, options);
+  const sourceFiles = checkpointGitSourceFiles(repoDir);
+  return commits
+    .map((commit) => {
+      const diff = gitShowDiff(repoDir, commit.hash, options);
+      if (!diff) return null;
+      return checkpointArtifact({
+        kind: "git-commit",
+        checkpointId: commit.hash.slice(0, 12),
+        commit: commit.hash,
+        summary: commit.subject,
+        diff,
+        timestamp: commit.timestamp,
+        sourcePath: repoDir,
+        sourceFiles
+      });
+    })
+    .filter(Boolean);
+}
+
+function gitCheckpointCommits(repoDir, options = {}) {
+  const limit = positiveInteger(options.gitCommitLimit, DEFAULT_GIT_COMMITS);
+  const output = git(repoDir, ["log", `--max-count=${limit}`, "--format=%H%x1f%ct%x1f%s"], options);
+  if (!output) return [];
+  return output
+    .split(/\r?\n/)
+    .map((line) => {
+      const [hash, unixSeconds, subject] = line.split("\x1f");
+      if (!hash) return null;
+      const ms = Number(unixSeconds) * 1000;
+      return {
+        hash,
+        timestamp: Number.isFinite(ms) ? new Date(ms).toISOString() : undefined,
+        subject: subject || ""
+      };
+    })
+    .filter(Boolean);
+}
+
+function gitShowDiff(repoDir, commit, options = {}) {
+  const diff = git(repoDir, ["show", "--format=", "--no-ext-diff", "--no-color", "--find-renames", "--find-copies", commit], options);
+  return looksLikeUnifiedDiff(diff) ? diff.trim() : "";
+}
+
+function git(repoDir, args, options = {}) {
+  try {
+    return execFileSync("git", ["-C", repoDir, ...args], {
+      encoding: "utf8",
+      timeout: positiveInteger(options.gitTimeoutMs, 5000),
+      maxBuffer: positiveInteger(options.gitMaxBuffer, DEFAULT_MAX_FILE_BYTES * 2),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
+}
+
+function checkpointGitSourceFiles(repoDir) {
+  const gitDir = path.join(repoDir, ".git");
+  const files = [
+    path.join(gitDir, "HEAD"),
+    path.join(gitDir, "config"),
+    path.join(gitDir, "packed-refs"),
+    path.join(gitDir, "logs", "HEAD")
+  ].filter((file) => safeStat(file)?.isFile());
+  for (const subdir of [path.join(gitDir, "refs", "heads"), path.join(gitDir, "refs", "tags")]) {
+    walkLimited(subdir, {
+      maxDepth: 4,
+      skipDirs: new Set(),
+      visitFile(file) {
+        files.push(file);
+      }
+    });
+  }
+  return uniqueSorted(files);
+}
+
+function clineCheckpointToolCall(artifact) {
+  const args = {};
+  if (artifact.path) args.path = artifact.path;
+  if (artifact.diff) args.diff = artifact.diff;
+  if (artifact.old_string || artifact.new_string) {
+    args.old_string = artifact.old_string || "";
+    args.new_string = artifact.new_string || "";
+  }
+  if (artifact.checkpointId) args.checkpointId = artifact.checkpointId;
+  if (artifact.commit) args.commit = artifact.commit;
+  if (artifact.sourcePath) args.sourcePath = artifact.sourcePath;
+  const summary = artifactSummary(artifact);
+  return {
+    id: artifact.checkpointId ? `cline-checkpoint-${artifact.checkpointId}` : `cline-checkpoint-${hashId(JSON.stringify(args))}`,
+    name: "cline_checkpoint_diff",
+    displayName: "Cline Checkpoint Diff",
+    category: "edit",
+    title: "Cline checkpoint diff",
+    status: "completed",
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: artifact.path || undefined,
+    arguments: args,
+    provider: "cline"
+  };
+}
+
+function clineCheckpointMessage(toolCall, artifact) {
+  return {
+    role: "assistant",
+    content: "",
+    timestamp: artifact.timestamp,
+    metadata: {
+      provider: "cline",
+      source: "cline_checkpoints",
+      supplementary: true,
+      toolCalls: [toolCall]
+    }
+  };
+}
+
+function checkpointArtifact(value) {
+  return {
+    ...value,
+    sourceFiles: uniqueSorted(value.sourceFiles || [])
+  };
+}
+
+function pushUniqueArtifact(artifacts, seen, artifact) {
+  const key = hashId(JSON.stringify({
+    kind: artifact.kind,
+    path: artifact.path,
+    diff: artifact.diff,
+    old_string: artifact.old_string,
+    new_string: artifact.new_string,
+    commit: artifact.commit,
+    sourcePath: artifact.sourcePath
+  }));
+  if (seen.has(key)) return;
+  seen.add(key);
+  artifacts.push(artifact);
+}
+
+function artifactSummary(artifact) {
+  const label = artifact.path || artifact.summary || artifact.checkpointId || "checkpoint changes";
+  if (artifact.diff) return String(label).slice(0, 240);
+  if (artifact.old_string || artifact.new_string) return String(label).slice(0, 240);
+  return "checkpoint changes";
+}
+
+function normalizeDiffText(diff, file) {
+  const text = String(diff || "").trim();
+  if (!text) return "";
+  if (looksLikeUnifiedDiff(text) || looksLikeClineSearchReplace(text)) return text;
+  return file ? `diff --git a/${file} b/${file}\n${text}` : text;
+}
+
+function looksLikeUnifiedDiff(value) {
+  const text = typeof value === "string" ? value : "";
+  return /^diff --git\s/m.test(text) || /^@@\s/m.test(text) || (/^---\s/m.test(text) && /^\+\+\+\s/m.test(text));
+}
+
+function looksLikeClineSearchReplace(value) {
+  return typeof value === "string" && /<{7}\s+SEARCH[\s\S]*={7}[\s\S]*>{7}\s+REPLACE/.test(value);
+}
+
+function checkpointIdFromPath(file, taskDir) {
+  const relative = path.relative(taskDir || path.dirname(file), file);
+  const parts = relative.split(path.sep).filter(Boolean);
+  const checkpointIndex = parts.findIndex((part) => /^\.?checkpoints?$/i.test(part) || /^checkpoint[-_]?store$/i.test(part));
+  if (checkpointIndex >= 0 && parts[checkpointIndex + 1]) return parts[checkpointIndex + 1].replace(/\.[^.]+$/, "");
+  return path.basename(path.dirname(file)) || path.basename(file);
+}
+
+function isLikelyCheckpointContainerKey(key) {
+  return /checkpoint|snapshot|restore|history/i.test(key);
+}
+
+function isLikelyEditContainerKey(key) {
+  return /diff|patch|change|edit|file/i.test(key);
+}
+
+function walkLimited(root, options) {
+  const stat = safeStat(root);
+  if (!stat || !stat.isDirectory()) return;
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const skipDirs = options.skipDirs || new Set();
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const entryNames = entries.map((entry) => entry.name);
+    if (options.visitDir && options.visitDir(dir, entryNames) === false) return;
+    if (depth >= maxDepth) return;
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (skipDirs.has(entry.name)) continue;
+        walk(full, depth + 1);
+      } else if (entry.isFile() && options.visitFile) {
+        options.visitFile(full);
+      }
+    }
+  };
+  walk(root, 0);
+}
+
+function safeStat(file) {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+}
+
+function readUtf8(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function toIso(value) {
+  if (!value) return "";
+  if (value instanceof Date) return Number.isNaN(value.valueOf()) ? "" : value.toISOString();
+  if (typeof value === "number") {
+    const ms = value > 1e12 ? value : value * 1000;
+    const date = new Date(ms);
+    return Number.isNaN(date.valueOf()) ? "" : date.toISOString();
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.valueOf()) ? "" : date.toISOString();
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  }
+  return "";
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : fallback;
+}
+
+function hashId(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 24);
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+module.exports = {
+  clineCheckpointRoots,
+  clineCheckpointToolCall,
+  discoverClineCheckpointArtifacts,
+  readClineCheckpointDiffs
+};