@fased/fased 0.1.41 → 0.1.42

package/dist/plugin-sdk/chat-type-CK5stkc4.d.ts

@@ -0,0 +1,4 @@
+//#region src/channels/chat-type.d.ts
+type ChatType = "direct" | "group" | "channel";
+//#endregion
+export { ChatType as t };

package/dist/plugin-sdk/chunk-CuJIMshx.js

@@ -0,0 +1,341 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { xn as INTERNAL_MESSAGE_CHANNEL } from "./runtime-BUpqjZNM.js";
+import { n as resolveAccountEntry } from "./account-helpers-Bdfws46K.js";
+import { p as normalizeAccountId } from "./session-key-HSJ2KQTc.js";
+
+//#region src/shared/text-chunking.ts
+function chunkTextByBreakResolver(text, limit, resolveBreakIndex) {
+	if (!text) return [];
+	if (limit <= 0 || text.length <= limit) return [text];
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > limit) {
+		const candidateBreak = resolveBreakIndex(remaining.slice(0, limit));
+		const breakIdx = Number.isFinite(candidateBreak) && candidateBreak > 0 && candidateBreak <= limit ? candidateBreak : limit;
+		const chunk = remaining.slice(0, breakIdx).trimEnd();
+		if (chunk.length > 0) chunks.push(chunk);
+		const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+		const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+		remaining = remaining.slice(nextStart).trimStart();
+	}
+	if (remaining.length) chunks.push(remaining);
+	return chunks;
+}
+
+//#endregion
+//#region src/markdown/fences.ts
+function parseFenceSpans(buffer) {
+	const spans = [];
+	let open;
+	let offset = 0;
+	while (offset <= buffer.length) {
+		const nextNewline = buffer.indexOf("\n", offset);
+		const lineEnd = nextNewline === -1 ? buffer.length : nextNewline;
+		const line = buffer.slice(offset, lineEnd);
+		const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+		if (match) {
+			const indent = match[1];
+			const marker = match[2];
+			const markerChar = marker[0];
+			const markerLen = marker.length;
+			if (!open) open = {
+				start: offset,
+				markerChar,
+				markerLen,
+				openLine: line,
+				marker,
+				indent
+			};
+			else if (open.markerChar === markerChar && markerLen >= open.markerLen) {
+				const end = lineEnd;
+				spans.push({
+					start: open.start,
+					end,
+					openLine: open.openLine,
+					marker: open.marker,
+					indent: open.indent
+				});
+				open = void 0;
+			}
+		}
+		if (nextNewline === -1) break;
+		offset = nextNewline + 1;
+	}
+	if (open) spans.push({
+		start: open.start,
+		end: buffer.length,
+		openLine: open.openLine,
+		marker: open.marker,
+		indent: open.indent
+	});
+	return spans;
+}
+function findFenceSpanAt(spans, index) {
+	return spans.find((span) => index > span.start && index < span.end);
+}
+function isSafeFenceBreak(spans, index) {
+	return !findFenceSpanAt(spans, index);
+}
+
+//#endregion
+//#region src/auto-reply/chunk.ts
+var chunk_exports = /* @__PURE__ */ __exportAll({
+	chunkByNewline: () => chunkByNewline,
+	chunkByParagraph: () => chunkByParagraph,
+	chunkMarkdownText: () => chunkMarkdownText,
+	chunkMarkdownTextWithMode: () => chunkMarkdownTextWithMode,
+	chunkText: () => chunkText,
+	chunkTextWithMode: () => chunkTextWithMode,
+	resolveChunkMode: () => resolveChunkMode,
+	resolveTextChunkLimit: () => resolveTextChunkLimit
+});
+const DEFAULT_CHUNK_LIMIT = 4e3;
+const DEFAULT_CHUNK_MODE = "length";
+function resolveChunkLimitForProvider(cfgSection, accountId) {
+	if (!cfgSection) return;
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const accounts = cfgSection.accounts;
+	if (accounts && typeof accounts === "object") {
+		const direct = resolveAccountEntry(accounts, normalizedAccountId);
+		if (typeof direct?.textChunkLimit === "number") return direct.textChunkLimit;
+	}
+	return cfgSection.textChunkLimit;
+}
+function resolveTextChunkLimit(cfg, provider, accountId, opts) {
+	const fallback = typeof opts?.fallbackLimit === "number" && opts.fallbackLimit > 0 ? opts.fallbackLimit : DEFAULT_CHUNK_LIMIT;
+	const providerOverride = (() => {
+		if (!provider || provider === INTERNAL_MESSAGE_CHANNEL) return;
+		return resolveChunkLimitForProvider((cfg?.channels)?.[provider] ?? cfg?.[provider], accountId);
+	})();
+	if (typeof providerOverride === "number" && providerOverride > 0) return providerOverride;
+	return fallback;
+}
+function resolveChunkModeForProvider(cfgSection, accountId) {
+	if (!cfgSection) return;
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const accounts = cfgSection.accounts;
+	if (accounts && typeof accounts === "object") {
+		const direct = resolveAccountEntry(accounts, normalizedAccountId);
+		if (direct?.chunkMode) return direct.chunkMode;
+	}
+	return cfgSection.chunkMode;
+}
+function resolveChunkMode(cfg, provider, accountId) {
+	if (!provider || provider === INTERNAL_MESSAGE_CHANNEL) return DEFAULT_CHUNK_MODE;
+	return resolveChunkModeForProvider((cfg?.channels)?.[provider] ?? cfg?.[provider], accountId) ?? DEFAULT_CHUNK_MODE;
+}
+/**
+* Split text on newlines, trimming line whitespace.
+* Blank lines are folded into the next non-empty line as leading "\n" prefixes.
+* Long lines can be split by length (default) or kept intact via splitLongLines:false.
+*/
+function chunkByNewline(text, maxLineLength, opts) {
+	if (!text) return [];
+	if (maxLineLength <= 0) return text.trim() ? [text] : [];
+	const splitLongLines = opts?.splitLongLines !== false;
+	const trimLines = opts?.trimLines !== false;
+	const lines = splitByNewline(text, opts?.isSafeBreak);
+	const chunks = [];
+	let pendingBlankLines = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			pendingBlankLines += 1;
+			continue;
+		}
+		const maxPrefix = Math.max(0, maxLineLength - 1);
+		const cappedBlankLines = pendingBlankLines > 0 ? Math.min(pendingBlankLines, maxPrefix) : 0;
+		const prefix = cappedBlankLines > 0 ? "\n".repeat(cappedBlankLines) : "";
+		pendingBlankLines = 0;
+		const lineValue = trimLines ? trimmed : line;
+		if (!splitLongLines || lineValue.length + prefix.length <= maxLineLength) {
+			chunks.push(prefix + lineValue);
+			continue;
+		}
+		const firstLimit = Math.max(1, maxLineLength - prefix.length);
+		const first = lineValue.slice(0, firstLimit);
+		chunks.push(prefix + first);
+		const remaining = lineValue.slice(firstLimit);
+		if (remaining) chunks.push(...chunkText(remaining, maxLineLength));
+	}
+	if (pendingBlankLines > 0 && chunks.length > 0) chunks[chunks.length - 1] += "\n".repeat(pendingBlankLines);
+	return chunks;
+}
+/**
+* Split text into chunks on paragraph boundaries (blank lines), preserving lists and
+* single-newline line wraps inside paragraphs.
+*
+* - Only breaks at paragraph separators ("\n\n" or more, allowing whitespace on blank lines)
+* - Packs multiple paragraphs into a single chunk up to `limit`
+* - Falls back to length-based splitting when a single paragraph exceeds `limit`
+*   (unless `splitLongParagraphs` is disabled)
+*/
+function chunkByParagraph(text, limit, opts) {
+	if (!text) return [];
+	if (limit <= 0) return [text];
+	const splitLongParagraphs = opts?.splitLongParagraphs !== false;
+	const normalized = text.replace(/\r\n?/g, "\n");
+	if (!/\n[\t ]*\n+/.test(normalized)) {
+		if (normalized.length <= limit) return [normalized];
+		if (!splitLongParagraphs) return [normalized];
+		return chunkText(normalized, limit);
+	}
+	const spans = parseFenceSpans(normalized);
+	const parts = [];
+	const re = /\n[\t ]*\n+/g;
+	let lastIndex = 0;
+	for (const match of normalized.matchAll(re)) {
+		const idx = match.index ?? 0;
+		if (!isSafeFenceBreak(spans, idx)) continue;
+		parts.push(normalized.slice(lastIndex, idx));
+		lastIndex = idx + match[0].length;
+	}
+	parts.push(normalized.slice(lastIndex));
+	const chunks = [];
+	for (const part of parts) {
+		const paragraph = part.replace(/\s+$/g, "");
+		if (!paragraph.trim()) continue;
+		if (paragraph.length <= limit) chunks.push(paragraph);
+		else if (!splitLongParagraphs) chunks.push(paragraph);
+		else chunks.push(...chunkText(paragraph, limit));
+	}
+	return chunks;
+}
+/**
+* Unified chunking function that dispatches based on mode.
+*/
+function chunkTextWithMode(text, limit, mode) {
+	if (mode === "newline") return chunkByParagraph(text, limit);
+	return chunkText(text, limit);
+}
+function chunkMarkdownTextWithMode(text, limit, mode) {
+	if (mode === "newline") {
+		const paragraphChunks = chunkByParagraph(text, limit, { splitLongParagraphs: false });
+		const out = [];
+		for (const chunk of paragraphChunks) {
+			const nested = chunkMarkdownText(chunk, limit);
+			if (!nested.length && chunk) out.push(chunk);
+			else out.push(...nested);
+		}
+		return out;
+	}
+	return chunkMarkdownText(text, limit);
+}
+function splitByNewline(text, isSafeBreak = () => true) {
+	const lines = [];
+	let start = 0;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n" && isSafeBreak(i)) {
+		lines.push(text.slice(start, i));
+		start = i + 1;
+	}
+	lines.push(text.slice(start));
+	return lines;
+}
+function resolveChunkEarlyReturn(text, limit) {
+	if (!text) return [];
+	if (limit <= 0) return [text];
+	if (text.length <= limit) return [text];
+}
+function chunkText(text, limit) {
+	const early = resolveChunkEarlyReturn(text, limit);
+	if (early) return early;
+	return chunkTextByBreakResolver(text, limit, (window) => {
+		const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window);
+		return lastNewline > 0 ? lastNewline : lastWhitespace;
+	});
+}
+function chunkMarkdownText(text, limit) {
+	const early = resolveChunkEarlyReturn(text, limit);
+	if (early) return early;
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > limit) {
+		const spans = parseFenceSpans(remaining);
+		const softBreak = pickSafeBreakIndex(remaining.slice(0, limit), spans);
+		let breakIdx = softBreak > 0 ? softBreak : limit;
+		const initialFence = isSafeFenceBreak(spans, breakIdx) ? void 0 : findFenceSpanAt(spans, breakIdx);
+		let fenceToSplit = initialFence;
+		if (initialFence) {
+			const closeLine = `${initialFence.indent}${initialFence.marker}`;
+			const maxIdxIfNeedNewline = limit - (closeLine.length + 1);
+			if (maxIdxIfNeedNewline <= 0) {
+				fenceToSplit = void 0;
+				breakIdx = limit;
+			} else {
+				const minProgressIdx = Math.min(remaining.length, initialFence.start + initialFence.openLine.length + 2);
+				const maxIdxIfAlreadyNewline = limit - closeLine.length;
+				let pickedNewline = false;
+				let lastNewline = remaining.lastIndexOf("\n", Math.max(0, maxIdxIfAlreadyNewline - 1));
+				while (lastNewline !== -1) {
+					const candidateBreak = lastNewline + 1;
+					if (candidateBreak < minProgressIdx) break;
+					const candidateFence = findFenceSpanAt(spans, candidateBreak);
+					if (candidateFence && candidateFence.start === initialFence.start) {
+						breakIdx = Math.max(1, candidateBreak);
+						pickedNewline = true;
+						break;
+					}
+					lastNewline = remaining.lastIndexOf("\n", lastNewline - 1);
+				}
+				if (!pickedNewline) if (minProgressIdx > maxIdxIfAlreadyNewline) {
+					fenceToSplit = void 0;
+					breakIdx = limit;
+				} else breakIdx = Math.max(minProgressIdx, maxIdxIfNeedNewline);
+			}
+			const fenceAtBreak = findFenceSpanAt(spans, breakIdx);
+			fenceToSplit = fenceAtBreak && fenceAtBreak.start === initialFence.start ? fenceAtBreak : void 0;
+		}
+		let rawChunk = remaining.slice(0, breakIdx);
+		if (!rawChunk) break;
+		const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+		const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+		let next = remaining.slice(nextStart);
+		if (fenceToSplit) {
+			const closeLine = `${fenceToSplit.indent}${fenceToSplit.marker}`;
+			rawChunk = rawChunk.endsWith("\n") ? `${rawChunk}${closeLine}` : `${rawChunk}\n${closeLine}`;
+			next = `${fenceToSplit.openLine}\n${next}`;
+		} else next = stripLeadingNewlines(next);
+		chunks.push(rawChunk);
+		remaining = next;
+	}
+	if (remaining.length) chunks.push(remaining);
+	return chunks;
+}
+function stripLeadingNewlines(value) {
+	let i = 0;
+	while (i < value.length && value[i] === "\n") i++;
+	return i > 0 ? value.slice(i) : value;
+}
+function pickSafeBreakIndex(window, spans) {
+	const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window, (index) => isSafeFenceBreak(spans, index));
+	if (lastNewline > 0) return lastNewline;
+	if (lastWhitespace > 0) return lastWhitespace;
+	return -1;
+}
+function scanParenAwareBreakpoints(window, isAllowed = () => true) {
+	let lastNewline = -1;
+	let lastWhitespace = -1;
+	let depth = 0;
+	for (let i = 0; i < window.length; i++) {
+		if (!isAllowed(i)) continue;
+		const char = window[i];
+		if (char === "(") {
+			depth += 1;
+			continue;
+		}
+		if (char === ")" && depth > 0) {
+			depth -= 1;
+			continue;
+		}
+		if (depth !== 0) continue;
+		if (char === "\n") lastNewline = i;
+		else if (/\s/.test(char)) lastWhitespace = i;
+	}
+	return {
+		lastNewline,
+		lastWhitespace
+	};
+}
+
+//#endregion
+export { chunkText as a, resolveChunkMode as c, isSafeFenceBreak as d, parseFenceSpans as f, chunkMarkdownTextWithMode as i, resolveTextChunkLimit as l, chunkByParagraph as n, chunkTextWithMode as o, chunkTextByBreakResolver as p, chunkMarkdownText as r, chunk_exports as s, chunkByNewline as t, findFenceSpanAt as u };

package/dist/plugin-sdk/chunk-items-me0j1xjK.js

@@ -0,0 +1,34 @@
+import { ht as wrapExternalContent } from "./pi-embedded-runner-C6HkZJ5E.js";
+
+//#region src/security/channel-metadata.ts
+const DEFAULT_MAX_CHARS = 800;
+const DEFAULT_MAX_ENTRY_CHARS = 400;
+function normalizeEntry(entry) {
+	return entry.replace(/\s+/g, " ").trim();
+}
+function truncateText(value, maxChars) {
+	if (maxChars <= 0) return "";
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+function buildUntrustedChannelMetadata(params) {
+	const deduped = params.entries.map((entry) => typeof entry === "string" ? normalizeEntry(entry) : "").filter((entry) => Boolean(entry)).map((entry) => truncateText(entry, DEFAULT_MAX_ENTRY_CHARS)).filter((entry, index, list) => list.indexOf(entry) === index);
+	if (deduped.length === 0) return;
+	const body = deduped.join("\n");
+	return wrapExternalContent(truncateText(`${`UNTRUSTED channel metadata (${params.source})`}\n${`${params.label}:\n${body}`}`, params.maxChars ?? DEFAULT_MAX_CHARS), {
+		source: "channel_metadata",
+		includeWarning: false
+	});
+}
+
+//#endregion
+//#region src/utils/chunk-items.ts
+function chunkItems(items, size) {
+	if (size <= 0) return [Array.from(items)];
+	const rows = [];
+	for (let i = 0; i < items.length; i += size) rows.push(items.slice(i, i + size));
+	return rows;
+}
+
+//#endregion
+export { buildUntrustedChannelMetadata as n, chunkItems as t };

package/dist/plugin-sdk/command-status.d.ts

@@ -1 +1,20 @@
-export * from "./src/plugin-sdk/command-status.js";
+import { At as FasedAgentConfig } from "./types.plugin-CvUiB3Kh.js";
+import { t as SkillCommandSpec } from "./types-CBCtqtMn.js";
+
+//#region src/auto-reply/status.d.ts
+declare function buildHelpMessage(cfg?: FasedAgentConfig): string;
+type CommandsMessageOptions = {
+  page?: number;
+  surface?: string;
+};
+type CommandsMessageResult = {
+  text: string;
+  totalPages: number;
+  currentPage: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+};
+declare function buildCommandsMessage(cfg?: FasedAgentConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): string;
+declare function buildCommandsMessagePaginated(cfg?: FasedAgentConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): CommandsMessageResult;
+//#endregion
+export { type CommandsMessageOptions, type CommandsMessageResult, buildCommandsMessage, buildCommandsMessagePaginated, buildHelpMessage };

package/dist/plugin-sdk/command-status.js

@@ -1,49 +1,60 @@
-import "./config-CgwTaper.js";
-import "./paths-GdhK5mV_.js";
-import "./globals-BtKmaIS3.js";
-import "./utils-LGKVujSU.js";
-import "./subsystem-BmpnSVOu.js";
-import "./agent-scope-BuTbywla.js";
-import "./redact-Ck-wgswc.js";
-import "./github-copilot-token-Djqpy66R.js";
-import "./retry-Cq65ROXv.js";
-import "./registry-DNkJsNsz.js";
-import "./accounts-BJFheJNv.js";
-import "./accounts-BRbbLNW_.js";
-import "./accounts-BwkH5bTD.js";
-import "./tokens-BK5rrwBB.js";
-import "./allow-list-CBtbuDI8.js";
-import "./paths-DTurNPnO.js";
-import { n as buildCommandsMessagePaginated, r as buildHelpMessage, t as buildCommandsMessage } from "./status-B2vb7zNW.js";
-import "./runtime-dependency-B-1u41Ph.js";
-import "./ssrf-Cce6LubA.js";
-import "./skill-commands-hyZA0LE3.js";
-import "./pi-model-discovery-DadlvsZW.js";
-import "./reply-prefix-Y14LY6Rn.js";
-import "./media-C7YT4DeU.js";
-import "./path-alias-guards-C76pC928.js";
-import "./fs-safe-BDnJzutp.js";
-import "./diagnostic-DpyvOvs2.js";
-import "./chunk-KCxbJLsV.js";
-import "./markdown-tables-DWUNvLrc.js";
-import "./send-BBYcgXA4.js";
-import "./fetch-guard-BLdujDnt.js";
-import "./outbound-attachment-D6tj5Y5H.js";
-import "./fetch-xfeOsibm.js";
-import "./common-DJWrErdE.js";
-import "./commands-registry-DoWdYAJd.js";
-import "./thread-bindings.state-D8kN2X6H.js";
-import "./memory-search-B-0Fwnrp.js";
-import "./manager-9see0IX5.js";
-import "./query-expansion-DjJAUtDU.js";
-import "./diagnostic-session-state-CT36_PCE.js";
-import "./wsl-DcM2PgSS.js";
-import "./sandbox-paths-DMnFyOaA.js";
-import "./directory-live-8umGGN7a.js";
-import "./targets-t1hbjHdJ.js";
-import "./send-D3836_UN.js";
-import "./resolve-route-DO0WR4nB.js";
-import "./render-C9LkRUhd.js";
-import "./tables-BD7H5ug-.js";
+import { bt as buildCommandsMessagePaginated, xt as buildHelpMessage, yt as buildCommandsMessage } from "./pi-embedded-runner-C6HkZJ5E.js";
+import "./runtime-BUpqjZNM.js";
+import "./subsystem-DBPNbQDQ.js";
+import "./globals-B_jjtAje.js";
+import "./paths-BEmvSyOV.js";
+import "./utils-CYk9EKoq.js";
+import "./config-DKNrb8oT.js";
+import "./agent-scope-BbgPlhtw.js";
+import "./accounts-RHZyaB73.js";
+import "./accounts-CuqIKU8X.js";
+import "./logger-BbFvCoKk.js";
+import "./exec-DQ8j4Fm3.js";
+import "./accounts-Bz_2QZSt.js";
+import "./allow-list-yqasgPpz.js";
+import "./redact-CwCz68Mi.js";
+import "./github-copilot-token-Dgug856m.js";
+import "./retry-DycQ4ymF.js";
+import "./paths-B88DQEK8.js";
+import "./ip-BkeyFRJr.js";
+import "./ssrf-D_4q0mKh.js";
+import "./fetch-guard-CxXvFYq5.js";
+import "./send-DGUAXb2b.js";
+import "./links-D5ecKoG9.js";
+import "./wsl-Cw-xOsqF.js";
+import "./pairing-store-BdOcH_GA.js";
+import "./chunk-CuJIMshx.js";
+import "./reply-prefix-CbPHNXlm.js";
+import "./tokens-Do_JU4Rh.js";
+import "./device-pairing-J1IH1jFl.js";
+import "./pairing-token-HQpaqod5.js";
+import "./diagnostic-C16gioN6.js";
+import "./diagnostic-session-state-B-9PL5r7.js";
+import "./optional-runtime-dependency-Bt_3Yigu.js";
+import "./image-ops-BSQmb-17.js";
+import "./wallet-status-D9UVH6k9.js";
+import "./pi-model-discovery-DQdXL_-F.js";
+import "./runtime-dependency-B5Fut2tT.js";
+import "./ws-CxmRDbD9.js";
+import "./path-alias-guards-BlIJ0AmG.js";
+import "./fs-safe-DztQeyQe.js";
+import "./markdown-tables-DrB-IM8r.js";
+import "./media-D8pWjqEt.js";
+import "./send-DWB5HFdb.js";
+import "./outbound-attachment-C9oadpUP.js";
+import "./fetch-RV7QDF43.js";
+import "./thread-bindings.state-DYYR9qeT.js";
+import "./memory-search-DHSeU4pJ.js";
+import "./manager-DQ1dH8OM.js";
+import "./query-expansion-BM7lmqaP.js";
+import "./common-C90EHP1w.js";
+import "./commands-registry-DwQIFJmL.js";
+import "./skill-commands-DCnCOVR_.js";
+import "./directory-live-G7AN8y8N.js";
+import "./targets-BgSHco9b.js";
+import "./sandbox-paths-fc-HFGJr.js";
+import "./resolve-route-wp5xq4Ws.js";
+import "./render-K7NwXvVu.js";
+import "./tables-DX84FwPB.js";
 
 export { buildCommandsMessage, buildCommandsMessagePaginated, buildHelpMessage };