nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.2

package/chunk-WJZOQR2J.js

@@ -0,0 +1,151 @@
+// packages/ai/attachments/attachmentPart.ts
+var ATTACHMENT_PART_TYPE = "attachment";
+var ATTACHMENT_PART_VERSION = 1;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var nonEmptyString = (value) => typeof value === "string" && value.trim() ? value : null;
+var isAttachmentCandidate = (part) => isRecord(part) && part.type === ATTACHMENT_PART_TYPE;
+var readSource = (part) => {
+  const raw = part.source;
+  if (raw !== void 0 && raw !== null) {
+    if (!isRecord(raw)) return { invalid: "source \u4E0D\u662F\u5BF9\u8C61" };
+    if (raw.kind === "remote-file") {
+      const fileKey = nonEmptyString(raw.fileKey);
+      return fileKey ? { source: { kind: "remote-file", fileKey }, legacyFileKey: false } : { invalid: "remote-file source \u7F3A fileKey" };
+    }
+    if (raw.kind === "local-file") {
+      const path = nonEmptyString(raw.path);
+      const machineId = nonEmptyString(raw.machineId);
+      if (!path) return { invalid: "local-file source \u7F3A path" };
+      if (!machineId) return { invalid: "local-file source \u7F3A machineId" };
+      const workspaceRoot = nonEmptyString(raw.workspaceRoot);
+      return {
+        source: {
+          kind: "local-file",
+          path,
+          machineId,
+          ...workspaceRoot ? { workspaceRoot } : {}
+        },
+        legacyFileKey: false
+      };
+    }
+    return { invalid: `\u672A\u77E5 source.kind: ${String(raw.kind)}` };
+  }
+  const legacyFileKey = nonEmptyString(part.fileKey);
+  if (legacyFileKey) {
+    return { source: { kind: "remote-file", fileKey: legacyFileKey }, legacyFileKey: true };
+  }
+  return { invalid: "\u7F3A source\uFF08\u4E5F\u65E0\u53EF\u517C\u5BB9\u7684\u9876\u5C42 fileKey\uFF09" };
+};
+var normalizeAttachmentPart = (part) => {
+  if (!isAttachmentCandidate(part)) {
+    return { status: "invalid", reason: "not-attachment", detail: "type !== 'attachment'" };
+  }
+  if (part.v !== ATTACHMENT_PART_VERSION) {
+    const version = part.v;
+    return {
+      status: "unsupported-version",
+      version: typeof version === "number" && Number.isFinite(version) ? version : null,
+      detail: `v=${String(version)} \u4E0D\u662F\u5F53\u524D reader \u5DF2\u77E5\u7684\u7248\u672C`
+    };
+  }
+  const source = readSource(part);
+  if ("invalid" in source) {
+    const given = part.source !== void 0 && part.source !== null;
+    return {
+      status: "invalid",
+      reason: given ? "unsupported-source" : "missing-source",
+      detail: source.invalid
+    };
+  }
+  const name = nonEmptyString(part.name);
+  const size = part.size;
+  const sizeOk = typeof size === "number" && Number.isFinite(size) && size >= 0;
+  if (!name || !sizeOk) {
+    const missing = [!name ? "name" : null, !sizeOk ? "size" : null].filter(Boolean).join("/");
+    return { status: "invalid", reason: "missing-metadata", detail: `\u5FEB\u7167\u5B57\u6BB5\u65E0\u6548: ${missing}` };
+  }
+  return {
+    status: "valid",
+    legacyFileKey: source.legacyFileKey,
+    attachment: {
+      type: ATTACHMENT_PART_TYPE,
+      v: ATTACHMENT_PART_VERSION,
+      source: source.source,
+      name,
+      mimeType: typeof part.mimeType === "string" ? part.mimeType : "",
+      size
+    }
+  };
+};
+var ext = (name) => {
+  const match = /\.([a-z0-9]+)$/i.exec(name.trim());
+  return match ? match[1].toLowerCase() : "";
+};
+var EXT_KIND = {};
+var register = (kind, list) => {
+  for (const e of list.split(" ")) {
+    if (EXT_KIND[e]) {
+      throw new Error(`attachment EXT_KIND \u51B2\u7A81: .${e} \u5DF2\u662F ${EXT_KIND[e]}\uFF0C\u53C8\u767B\u8BB0\u4E3A ${kind}`);
+    }
+    EXT_KIND[e] = kind;
+  }
+};
+register("image", "avif bmp gif heic heif ico jpg jpeg png svg tif tiff webp");
+register("audio", "aac flac m4a mp3 oga ogg opus wav weba wma amr");
+register("video", "avi m4v mkv mov mp4 mpeg mpg webm wmv 3gp flv");
+register("document", "pdf doc docx odt rtf ppt pptx odp xls xlsx ods csv epub pages numbers key");
+register("archive", "zip rar 7z tar gz tgz bz2 xz zst apk aab ipa jar war dmg iso deb rpm");
+register(
+  "text",
+  "txt md mdx markdown json jsonl yaml yml toml ini cfg conf env log xml html htm css scss sass less js jsx ts tsx mjs cjs py rb go rs java kt swift c h cc cpp hpp cs php sh bash zsh sql graphql proto vue svelte lua r dart"
+);
+var MPEG_TS_MIME = /mp2t|mpeg-?ts|x-mpegts/;
+var attachmentKind = (args) => {
+  const e = ext(typeof args.name === "string" ? args.name : "");
+  const mime = (typeof args.mimeType === "string" ? args.mimeType : "").toLowerCase();
+  if (e === "ts" && MPEG_TS_MIME.test(mime)) return "video";
+  const byExt = EXT_KIND[e];
+  if (byExt) return byExt;
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("audio/")) return "audio";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("text/")) return "text";
+  if (mime === "application/pdf") return "document";
+  if (/zip|x-tar|x-7z|x-rar|gzip|android\.package/.test(mime)) return "archive";
+  if (/json|xml|javascript|yaml/.test(mime)) return "text";
+  return "binary";
+};
+var formatSize = (bytes) => {
+  if (!Number.isFinite(bytes) || bytes < 0) return "";
+  if (bytes < 1) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+  const value = bytes / 1024 ** i;
+  return `${i === 0 ? Math.round(value) : value.toFixed(1)} ${units[i]}`;
+};
+var describeValidatedAttachment = (attachment) => {
+  const kind = attachmentKind(attachment);
+  const meta = [attachment.mimeType.trim(), formatSize(attachment.size)].filter(Boolean).join(" \xB7 ");
+  const locator = attachment.source.kind === "remote-file" ? ` \xB7 fileKey=${attachment.source.fileKey}` : "";
+  const head = `[\u9644\u4EF6] ${attachment.name.trim()}${meta ? ` \xB7 ${meta}` : ""} \xB7 kind=${kind}${locator}`;
+  return kind === "binary" ? `${head}
+\uFF08\u8BE5\u7C7B\u578B\u6682\u65E0\u6CD5\u8BFB\u53D6\u5185\u5BB9\uFF09` : head;
+};
+var displayName = (part) => {
+  const name = isRecord(part) ? part.name : void 0;
+  return typeof name === "string" && name.trim() ? name.trim() : "\u672A\u547D\u540D\u6587\u4EF6";
+};
+var describeAttachmentForModel = (part) => {
+  if (!isAttachmentCandidate(part)) return "[\u672A\u8BC6\u522B\u7684\u9644\u4EF6]";
+  const normalized = normalizeAttachmentPart(part);
+  if (normalized.status !== "valid") return `[\u9644\u4EF6\u4E0D\u53EF\u7528: ${displayName(part)}]`;
+  return describeValidatedAttachment(normalized.attachment);
+};
+
+export {
+  ATTACHMENT_PART_TYPE,
+  ATTACHMENT_PART_VERSION,
+  normalizeAttachmentPart,
+  attachmentKind,
+  describeAttachmentForModel
+};

package/{chunk-AUDNYVRC.js → chunk-XETG4RIX.js}

@@ -1,13 +1,13 @@
-import {
-  dump,
-  load
-} from "./chunk-KHCLMKZZ.js";
 import {
   asTrimmedNonEmptyStringArray
-} from "./chunk-3AH7LNUB.js";
+} from "./chunk-I42VC5KR.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
+import {
+  dump,
+  load
+} from "./chunk-KHCLMKZZ.js";
 
 // packages/ai/skills/skillDocProtocol.ts
 var SKILL_DOC_ENUMS = {

package/{chunk-MX574M24.js → chunk-XI7DGLUK.js}

@@ -1,9 +1,9 @@
-import {
-  dialogMessageRange
-} from "./chunk-3AH7LNUB.js";
 import {
   isTombstoneRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
+import {
+  dialogMessageRange
+} from "./chunk-5EMSBTQ6.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";

package/{chunk-3L2WKC3W.js → chunk-XPWGOTBQ.js}

@@ -24,6 +24,12 @@ async function isDrainExhaustedResponse(response) {
   }
 }
 
+// packages/core/positiveFiniteNumberOrFallback.ts
+function parsePositiveFiniteNumberOrFallback(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 // packages/core/retryAfterMs.ts
 function normalizeNonNegativeMs(value, fallbackMs) {
   const parsed = Number(value);
@@ -51,5 +57,6 @@ export {
   createDrainExhaustedResponse,
   isDrainExhaustedResponse,
   normalizeNonNegativeMs,
-  parseRetryAfterHeaderMs
+  parseRetryAfterHeaderMs,
+  parsePositiveFiniteNumberOrFallback
 };