@cydm/pie 1.0.18 → 1.0.20

package/dist/chunks/{chunk-5DA2D3K2.js → chunk-VESPMEDG.js}

@@ -3107,6 +3107,27 @@ function calculateCost(model, usage) {
   };
 }
 
+// ../../packages/platform/src/text-hash.ts
+function createTextHasher() {
+  let hash = 2166136261;
+  return {
+    update(text) {
+      for (let index = 0; index < text.length; index++) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619) >>> 0;
+      }
+    },
+    digest() {
+      return hash.toString(16).padStart(8, "0");
+    }
+  };
+}
+function hashText(text) {
+  const hasher = createTextHasher();
+  hasher.update(text);
+  return hasher.digest();
+}
+
 // ../../packages/platform/src/detector.ts
 function isPuerTS() {
   try {
@@ -3252,6 +3273,17 @@ function convertStats(stats) {
     mtime: stats.mtime
   };
 }
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf-8");
+}
+function normalizeRangeOptions(options) {
+  return {
+    offsetLine: Math.max(0, Math.floor(options?.offsetLine ?? 0)),
+    limitLines: options?.limitLines === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(options.limitLines)),
+    maxOutputLines: Math.max(0, Math.floor(options?.maxOutputLines ?? Number.POSITIVE_INFINITY)),
+    maxOutputBytes: Math.max(0, Math.floor(options?.maxOutputBytes ?? Number.POSITIVE_INFINITY))
+  };
+}
 var NodeFileSystem = class {
   platform = "node";
   sep;
@@ -3266,6 +3298,142 @@ var NodeFileSystem = class {
   readFileSync(path, encoding = "utf-8") {
     return getNodeFs().readFileSync(path, encoding);
   }
+  async readTextRange(path, options, signal) {
+    const fs = getNodeFs();
+    const range = normalizeRangeOptions(options);
+    const stat = await fs.promises.stat(path);
+    const fullHasher = createTextHasher();
+    const selectedHasher = createTextHasher();
+    const outputLines = [];
+    let lineStarted = false;
+    let currentLineSelected = false;
+    let currentLineBytes = 0;
+    let currentOutputLine = "";
+    let currentOutputLineBytes = 0;
+    let currentOutputPrefixBytes = 0;
+    let currentLineCanOutput = false;
+    let lineIndex = 0;
+    let selectedLines = 0;
+    let selectedBytes = 0;
+    let firstLineBytes = 0;
+    let outputBytes = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    let firstLineExceedsLimit = false;
+    const selectedEndLine = Number.isFinite(range.limitLines) ? range.offsetLine + range.limitLines : Number.POSITIVE_INFINITY;
+    const startLine = () => {
+      if (lineStarted) return;
+      currentLineSelected = lineIndex >= range.offsetLine && lineIndex < selectedEndLine;
+      currentLineBytes = 0;
+      currentOutputLine = "";
+      currentOutputLineBytes = 0;
+      currentOutputPrefixBytes = outputLines.length > 0 ? 1 : 0;
+      currentLineCanOutput = false;
+      lineStarted = true;
+      if (!currentLineSelected) return;
+      if (selectedLines > 0) {
+        selectedHasher.update("\n");
+        selectedBytes += 1;
+      }
+      if (!truncated && !firstLineExceedsLimit) {
+        if (outputLines.length >= range.maxOutputLines) {
+          truncated = true;
+          truncatedBy = "lines";
+        } else {
+          currentLineCanOutput = true;
+        }
+      }
+    };
+    const scanLineChar = (char) => {
+      startLine();
+      if (!currentLineSelected) return;
+      selectedHasher.update(char);
+      const charBytes = byteLength(char);
+      currentLineBytes += charBytes;
+      selectedBytes += charBytes;
+      if (selectedLines === 0 && currentLineBytes > range.maxOutputBytes) {
+        firstLineExceedsLimit = true;
+        truncated = true;
+        truncatedBy = "bytes";
+        currentLineCanOutput = false;
+        currentOutputLine = "";
+        currentOutputLineBytes = 0;
+        return;
+      }
+      if (!currentLineCanOutput) return;
+      const candidateOutputBytes = outputBytes + currentOutputPrefixBytes + currentOutputLineBytes + charBytes;
+      if (candidateOutputBytes > range.maxOutputBytes) {
+        truncated = true;
+        truncatedBy = "bytes";
+        currentLineCanOutput = false;
+        currentOutputLine = "";
+        currentOutputLineBytes = 0;
+        return;
+      }
+      currentOutputLine += char;
+      currentOutputLineBytes += charBytes;
+    };
+    const finishLine = () => {
+      startLine();
+      if (currentLineSelected) {
+        if (selectedLines === 0) {
+          firstLineBytes = currentLineBytes;
+        }
+        if (currentLineCanOutput) {
+          const candidateOutputBytes = outputBytes + currentOutputPrefixBytes + currentOutputLineBytes;
+          if (candidateOutputBytes > range.maxOutputBytes) {
+            truncated = true;
+            truncatedBy = "bytes";
+            currentLineCanOutput = false;
+          } else {
+            outputLines.push(currentOutputLine);
+            outputBytes = candidateOutputBytes;
+          }
+        }
+        selectedLines++;
+      }
+      lineStarted = false;
+      lineIndex++;
+    };
+    const stream = fs.createReadStream(path, { encoding: "utf-8" });
+    try {
+      for await (const chunk of stream) {
+        if (signal?.aborted) {
+          stream.destroy();
+          throw new Error("Operation aborted");
+        }
+        const text = String(chunk);
+        fullHasher.update(text);
+        for (const char of text) {
+          if (char === "\n") {
+            finishLine();
+          } else {
+            scanLineChar(char);
+          }
+        }
+      }
+      finishLine();
+    } finally {
+      stream.destroy();
+    }
+    return {
+      content: outputLines.join("\n"),
+      contentHash: fullHasher.digest(),
+      selectedContentHash: selectedHasher.digest(),
+      totalLines: lineIndex,
+      totalBytes: stat.size,
+      selectedLines,
+      selectedBytes,
+      firstLineBytes,
+      outputLines: outputLines.length,
+      outputBytes,
+      truncated,
+      truncatedBy,
+      firstLineExceedsLimit,
+      mtimeMs: stat.mtime.getTime(),
+      size: stat.size
+    };
+  }
   async writeFile(path, data, encoding = "utf-8") {
     return getNodeFs().promises.writeFile(path, data, encoding);
   }
@@ -3392,6 +3560,87 @@ function convertBridgeStatResult(result) {
     mtime: new Date((Number(result?.LastWriteTicksUtc || 0) - 621355968e9) / 1e4)
   };
 }
+function normalizeOptionalNumber(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function convertTextRangeResult(result) {
+  return {
+    content: String(result?.Content ?? ""),
+    contentHash: String(result?.ContentHash ?? ""),
+    selectedContentHash: String(result?.SelectedContentHash ?? ""),
+    totalLines: Number(result?.TotalLines ?? 0),
+    totalBytes: Number(result?.TotalBytes ?? 0),
+    selectedLines: Number(result?.SelectedLines ?? 0),
+    selectedBytes: Number(result?.SelectedBytes ?? 0),
+    firstLineBytes: Number(result?.FirstLineBytes ?? 0),
+    outputLines: Number(result?.OutputLines ?? 0),
+    outputBytes: Number(result?.OutputBytes ?? 0),
+    truncated: !!result?.Truncated,
+    truncatedBy: result?.TruncatedBy ? String(result.TruncatedBy) : null,
+    firstLineExceedsLimit: !!result?.FirstLineExceedsLimit,
+    mtimeMs: (Number(result?.LastWriteTicksUtc || 0) - 621355968e9) / 1e4,
+    size: Number(result?.Size ?? 0)
+  };
+}
+function byteLength2(text) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.byteLength(text, "utf-8");
+  }
+  return unescape(encodeURIComponent(text)).length;
+}
+function buildTextRangeFallback(content, stat, offsetLine, limitLines, maxOutputLines, maxOutputBytes) {
+  const lines = content.split("\n");
+  const endLine = Number.isFinite(limitLines) ? Math.min(lines.length, offsetLine + limitLines) : lines.length;
+  const selectedLinesArray = offsetLine >= lines.length ? [] : lines.slice(offsetLine, endLine);
+  const selectedContent = selectedLinesArray.join("\n");
+  const outputLines = [];
+  let outputBytes = 0;
+  let truncated = false;
+  let truncatedBy = null;
+  let firstLineExceedsLimit = false;
+  for (const line of selectedLinesArray) {
+    const lineBytes = byteLength2(line);
+    if (outputLines.length === 0 && lineBytes > maxOutputBytes) {
+      firstLineExceedsLimit = true;
+      truncated = true;
+      truncatedBy = "bytes";
+      break;
+    }
+    if (outputLines.length >= maxOutputLines) {
+      truncated = true;
+      truncatedBy = "lines";
+      break;
+    }
+    const candidateBytes = lineBytes + (outputLines.length > 0 ? 1 : 0);
+    if (outputBytes + candidateBytes > maxOutputBytes) {
+      truncated = true;
+      truncatedBy = "bytes";
+      break;
+    }
+    outputLines.push(line);
+    outputBytes += candidateBytes;
+  }
+  return {
+    content: outputLines.join("\n"),
+    contentHash: hashText(content),
+    selectedContentHash: hashText(selectedContent),
+    totalLines: lines.length,
+    totalBytes: stat.size,
+    selectedLines: selectedLinesArray.length,
+    selectedBytes: byteLength2(selectedContent),
+    firstLineBytes: selectedLinesArray.length > 0 ? byteLength2(selectedLinesArray[0]) : 0,
+    outputLines: outputLines.length,
+    outputBytes,
+    truncated,
+    truncatedBy,
+    firstLineExceedsLimit,
+    mtimeMs: stat.mtime.getTime(),
+    size: stat.size
+  };
+}
 function convertDateTime(dateTime) {
   if (!dateTime) return /* @__PURE__ */ new Date(0);
   const ticks = dateTime.get_Ticks?.() || 0;
@@ -3457,6 +3706,33 @@ var PuerTSFileSystem = class {
     }
     return IO.File.ReadAllText(normalizedPath);
   }
+  async readTextRange(path, options, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    const bridge = getPieFileBridge();
+    const normalizedPath = this.normalizePath(path);
+    if (typeof bridge.ReadTextRangeAsync !== "function") {
+      const content = await this.readFile(path, "utf-8");
+      const stat = await this.stat(path);
+      const offsetLine = normalizeOptionalNumber(options?.offsetLine, 0);
+      const limitLines = options?.limitLines === void 0 ? Number.POSITIVE_INFINITY : normalizeOptionalNumber(options.limitLines, 0);
+      const maxOutputLines = normalizeOptionalNumber(options?.maxOutputLines, Number.POSITIVE_INFINITY);
+      const maxOutputBytes = normalizeOptionalNumber(options?.maxOutputBytes, Number.POSITIVE_INFINITY);
+      return buildTextRangeFallback(content, stat, offsetLine, limitLines, maxOutputLines, maxOutputBytes);
+    }
+    const payload = await taskToPromise(bridge.ReadTextRangeAsync(
+      normalizedPath,
+      normalizeOptionalNumber(options?.offsetLine, 0),
+      options?.limitLines === void 0 ? -1 : normalizeOptionalNumber(options.limitLines, 0),
+      normalizeOptionalNumber(options?.maxOutputLines, -1),
+      normalizeOptionalNumber(options?.maxOutputBytes, -1)
+    ));
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    return convertTextRangeResult(JSON.parse(String(payload ?? "{}")));
+  }
   async writeFile(path, data, encoding = "utf-8") {
     const bridge = getPieFileBridge();
     const normalizedPath = this.normalizePath(path);
@@ -4381,6 +4657,31 @@ var FileSystemGateway = class {
     const fs = nodeRequire("fs");
     return fs.readFileSync(path, encoding);
   }
+  /**
+   * Read at most the first maxBytes of a file.
+   */
+  readFileHead(path, maxBytes, encoding = "utf-8") {
+    this.validatePath(path, "read");
+    const byteLimit = Math.max(0, Math.floor(maxBytes));
+    if (byteLimit === 0) return "";
+    const platform = detectPlatform();
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      if (!CS.System.IO.File.Exists(path)) {
+        throw new Error(`File not found: ${path}`);
+      }
+      return CS.System.IO.File.ReadAllText(path).slice(0, byteLimit);
+    }
+    const fs = nodeRequire("fs");
+    const fileSize = fs.existsSync(path) ? fs.statSync(path).size : 0;
+    const buffer = Buffer.alloc(Math.min(byteLimit, fileSize));
+    const fd = fs.openSync(path, "r");
+    try {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+      return buffer.subarray(0, bytesRead).toString(encoding);
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
   /**
    * Write file content
    */
@@ -4549,6 +4850,21 @@ var FileSystemGateway = class {
     if (!fs.existsSync(path)) return 0;
     return fs.statSync(path).size;
   }
+  /**
+   * Get file modified time in milliseconds since epoch.
+   */
+  getModifiedTime(path) {
+    this.validatePath(path, "getModifiedTime");
+    const platform = detectPlatform();
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      if (!CS.System.IO.File.Exists(path)) return 0;
+      const ticks = Number(CS.System.IO.File.GetLastWriteTimeUtc(path).Ticks);
+      return Number.isFinite(ticks) ? ticks / 1e4 - 621355968e5 : 0;
+    }
+    const fs = nodeRequire("fs");
+    if (!fs.existsSync(path)) return 0;
+    return fs.statSync(path).mtimeMs;
+  }
   /**
    * Get config
    */
@@ -9121,6 +9437,7 @@ registerApiProvider({
 });
 
 export {
+  hashText,
   detectPlatform,
   createLogger,
   setLogger,

package/dist/chunks/{chunk-MHFUWY7I.js → chunk-ZYOTRKU7.js}

@@ -8,10 +8,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-G4GV2CRT.js";
+} from "./chunk-NHR6EBM2.js";
 import {
   Type
-} from "./chunk-5DA2D3K2.js";
+} from "./chunk-VESPMEDG.js";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
@@ -978,6 +978,7 @@ export {
   getPackageDir,
   getThemesDir,
   getBuiltinDir,
+  VERSION,
   getConfigDir,
   getAgentDir,
   getCustomThemesDir,

package/dist/chunks/{src-6WPNVGT2.js → src-2FHZO63Y.js}

@@ -3,8 +3,8 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-VE2HDCNB.js";
-import "./chunk-5DA2D3K2.js";
+} from "./chunk-L5BJNCNG.js";
+import "./chunk-VESPMEDG.js";
 import "./chunk-TG2EQLX2.js";
 export {
   Agent,

package/dist/chunks/{test-stream-ZSKNLUEJ.js → test-stream-UW74PA6T.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-5DA2D3K2.js";
+} from "./chunk-VESPMEDG.js";
 import "./chunk-TG2EQLX2.js";
 
 // src/app/test-stream.ts