0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-LP3HHYQU.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+
+// packages/core/dist/agent/apply-patch.js
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var BEGIN = "*** Begin Patch";
+var END = "*** End Patch";
+function parsePatch(input) {
+  const text = input.replace(/\r\n/g, "\n");
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length === 0 || lines[0].trim() !== BEGIN) {
+    throw new Error(`apply_patch: envelope must start with "${BEGIN}" (got: ${lines[0] ?? "<empty>"})`);
+  }
+  if (lines[lines.length - 1].trim() !== END) {
+    throw new Error(`apply_patch: envelope must end with "${END}"`);
+  }
+  const body = lines.slice(1, -1);
+  const ops = [];
+  let i = 0;
+  while (i < body.length) {
+    const line = body[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      i += 1;
+      continue;
+    }
+    const addMatch = /^\*\*\* Add File: (.+)$/.exec(trimmed);
+    const replaceMatch = /^\*\*\* Replace File: (.+)$/.exec(trimmed);
+    const updateMatch = /^\*\*\* Update File: (.+)$/.exec(trimmed);
+    const deleteMatch = /^\*\*\* Delete File: (.+)$/.exec(trimmed);
+    if (addMatch || replaceMatch) {
+      const path = (addMatch?.[1] ?? replaceMatch[1]).trim();
+      const overwrite = replaceMatch !== null;
+      i += 1;
+      const contentLines = [];
+      while (i < body.length && !isOpHeader(body[i])) {
+        const ln = body[i];
+        if (ln.length === 0) {
+          contentLines.push("");
+        } else if (ln[0] === "+") {
+          contentLines.push(ln.slice(1));
+        } else {
+          throw new Error(`apply_patch: Add/Replace body lines must start with "+" (got: ${JSON.stringify(ln)})`);
+        }
+        i += 1;
+      }
+      ops.push({
+        kind: "add",
+        path,
+        contents: contentLines.join("\n"),
+        overwrite
+      });
+      continue;
+    }
+    if (deleteMatch) {
+      ops.push({ kind: "delete", path: deleteMatch[1].trim() });
+      i += 1;
+      continue;
+    }
+    if (updateMatch) {
+      const path = updateMatch[1].trim();
+      i += 1;
+      const hunks = [];
+      while (i < body.length && !isOpHeader(body[i])) {
+        const hunkLine = body[i];
+        if (!hunkLine.startsWith("@@")) {
+          throw new Error(`apply_patch: Update File body must begin with "@@ <anchor>" hunk header (got: ${JSON.stringify(hunkLine)})`);
+        }
+        const anchor = hunkLine.slice(2).trim();
+        i += 1;
+        const hunkBody = [];
+        while (i < body.length && !isOpHeader(body[i]) && !body[i].startsWith("@@")) {
+          const ln = body[i];
+          if (ln === "") {
+            hunkBody.push({ kind: "context", text: "" });
+          } else if (ln[0] === " ") {
+            hunkBody.push({ kind: "context", text: ln.slice(1) });
+          } else if (ln[0] === "+") {
+            hunkBody.push({ kind: "add", text: ln.slice(1) });
+          } else if (ln[0] === "-") {
+            hunkBody.push({ kind: "del", text: ln.slice(1) });
+          } else {
+            throw new Error(`apply_patch: Update hunk body lines must start with " ", "+", or "-" (got: ${JSON.stringify(ln)})`);
+          }
+          i += 1;
+        }
+        hunks.push({ anchor, body: hunkBody });
+      }
+      if (hunks.length === 0) {
+        throw new Error(`apply_patch: "Update File: ${path}" requires at least one "@@" hunk`);
+      }
+      ops.push({ kind: "update", path, hunks });
+      continue;
+    }
+    throw new Error(`apply_patch: unknown directive (got: ${JSON.stringify(trimmed)})`);
+  }
+  if (ops.length === 0) {
+    throw new Error("apply_patch: envelope contains no operations");
+  }
+  return ops;
+}
+function isOpHeader(line) {
+  return line.startsWith("*** Add File:") || line.startsWith("*** Replace File:") || line.startsWith("*** Update File:") || line.startsWith("*** Delete File:");
+}
+function applyPatchOps(ops, pathResolver) {
+  const applied = [];
+  for (const op of ops) {
+    const abs = pathResolver(op.path);
+    if (op.kind === "add") {
+      if (!op.overwrite && existsSync(abs)) {
+        throw new Error(`apply_patch: Add File "${op.path}" failed \u2014 file already exists. Use "*** Replace File: ${op.path}" to overwrite.`);
+      }
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, op.contents, "utf-8");
+      applied.push({ kind: "add", path: op.path });
+      continue;
+    }
+    if (op.kind === "delete") {
+      if (!existsSync(abs)) {
+        throw new Error(`apply_patch: Delete File "${op.path}" failed \u2014 file does not exist`);
+      }
+      unlinkSync(abs);
+      applied.push({ kind: "delete", path: op.path });
+      continue;
+    }
+    if (!existsSync(abs)) {
+      throw new Error(`apply_patch: Update File "${op.path}" failed \u2014 file does not exist`);
+    }
+    const original = readFileSync(abs, "utf-8");
+    const updated = applyUpdateHunks(original, op.path, op.hunks);
+    writeFileSync(abs, updated, "utf-8");
+    applied.push({ kind: "update", path: op.path });
+  }
+  return { applied };
+}
+function applyUpdateHunks(source, logicalPath, hunks) {
+  const hadTrailingNewline = source.endsWith("\n");
+  const sourceBody = hadTrailingNewline ? source.slice(0, -1) : source;
+  let lines = sourceBody.split("\n");
+  for (const hunk of hunks) {
+    const anchorIdx = locateAnchor(lines, hunk.anchor, logicalPath);
+    const { newLines, consumed } = applyOneHunk(lines, anchorIdx, hunk, logicalPath);
+    lines = [
+      ...lines.slice(0, anchorIdx),
+      ...newLines,
+      ...lines.slice(anchorIdx + consumed)
+    ];
+  }
+  return lines.join("\n") + (hadTrailingNewline ? "\n" : "");
+}
+function locateAnchor(lines, anchor, logicalPath) {
+  if (anchor === "") {
+    return 0;
+  }
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(anchor)) {
+      matches.push(i);
+    }
+  }
+  if (matches.length === 0) {
+    throw new Error(`apply_patch: anchor "${anchor}" not found in ${logicalPath}; refine the @@ anchor to a line that exists in the file`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`apply_patch: context "${anchor}" matches ${matches.length} locations in ${logicalPath}; refine the @@ anchor to be unique`);
+  }
+  return matches[0];
+}
+function applyOneHunk(lines, anchorIdx, hunk, logicalPath) {
+  const newLines = [];
+  let cursor = anchorIdx;
+  for (const entry of hunk.body) {
+    if (entry.kind === "context") {
+      const observed = lines[cursor];
+      if (observed === void 0 || observed !== entry.text) {
+        throw new Error(`apply_patch: context mismatch in ${logicalPath} at line ${cursor + 1}: expected ${JSON.stringify(entry.text)}, got ${JSON.stringify(observed ?? "<eof>")}`);
+      }
+      newLines.push(entry.text);
+      cursor += 1;
+      continue;
+    }
+    if (entry.kind === "del") {
+      const observed = lines[cursor];
+      if (observed === void 0 || observed !== entry.text) {
+        throw new Error(`apply_patch: removed line mismatch in ${logicalPath} at line ${cursor + 1}: expected ${JSON.stringify(entry.text)}, got ${JSON.stringify(observed ?? "<eof>")}`);
+      }
+      cursor += 1;
+      continue;
+    }
+    newLines.push(entry.text);
+  }
+  return { newLines, consumed: cursor - anchorIdx };
+}
+
+// packages/core/dist/agent/tools/scope-path.js
+import { lstatSync, realpathSync } from "node:fs";
+import { basename, dirname as dirname2, isAbsolute, resolve, sep } from "node:path";
+function pathEntryExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function canonicalizePath(path) {
+  const missingSegments = [];
+  let existingPath = path;
+  while (!pathEntryExists(existingPath)) {
+    const parent = dirname2(existingPath);
+    if (parent === existingPath) {
+      throw new Error(`Path does not have an existing parent: ${path}`);
+    }
+    missingSegments.unshift(basename(existingPath));
+    existingPath = parent;
+  }
+  return resolve(realpathSync(existingPath), ...missingSegments);
+}
+function isScopedPath(scopePath, inputPath) {
+  const root = realpathSync(scopePath);
+  const logicalCandidate = isAbsolute(inputPath) ? resolve(inputPath) : resolve(root, inputPath);
+  const candidate = canonicalizePath(logicalCandidate);
+  return candidate === root || candidate.startsWith(root + sep);
+}
+function resolveScopedPath(scopePath, inputPath) {
+  if (!isScopedPath(scopePath, inputPath)) {
+    throw new Error(`Path escapes the allowed scope: ${inputPath}`);
+  }
+  const root = realpathSync(scopePath);
+  const logicalCandidate = isAbsolute(inputPath) ? resolve(inputPath) : resolve(root, inputPath);
+  return canonicalizePath(logicalCandidate);
+}
+
+export {
+  parsePatch,
+  applyPatchOps,
+  resolveScopedPath
+};