poe-code 3.0.178 → 3.0.179

package/packages/design-system/dist/tokens/colors.js

@@ -0,0 +1,34 @@
+import chalk from "chalk";
+export const brand = "#a200ff";
+export const dark = {
+    header: (text) => chalk.magentaBright.bold(text),
+    divider: (text) => chalk.dim(text),
+    prompt: (text) => chalk.cyan(text),
+    number: (text) => chalk.cyanBright(text),
+    intro: (text) => chalk.bgMagenta.white(` Poe - ${text} `),
+    resolvedSymbol: chalk.magenta("◇"),
+    errorSymbol: chalk.red("■"),
+    accent: (text) => chalk.cyan(text),
+    muted: (text) => chalk.dim(text),
+    success: (text) => chalk.green(text),
+    warning: (text) => chalk.yellow(text),
+    error: (text) => chalk.red(text),
+    info: (text) => chalk.magenta(text),
+    badge: (text) => chalk.bgYellow.black(` ${text} `)
+};
+export const light = {
+    header: (text) => chalk.hex("#a200ff").bold(text),
+    divider: (text) => chalk.hex("#666666")(text),
+    prompt: (text) => chalk.hex("#006699").bold(text),
+    number: (text) => chalk.hex("#0077cc").bold(text),
+    intro: (text) => chalk.bgHex("#a200ff").white(` Poe - ${text} `),
+    resolvedSymbol: chalk.hex("#a200ff")("◇"),
+    errorSymbol: chalk.hex("#cc0000")("■"),
+    accent: (text) => chalk.hex("#006699").bold(text),
+    muted: (text) => chalk.hex("#666666")(text),
+    success: (text) => chalk.hex("#008800")(text),
+    warning: (text) => chalk.hex("#cc6600")(text),
+    error: (text) => chalk.hex("#cc0000")(text),
+    info: (text) => chalk.hex("#a200ff")(text),
+    badge: (text) => chalk.bgHex("#cc6600").white(` ${text} `)
+};

package/packages/design-system/dist/tokens/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./colors.js";
+export { spacing } from "./spacing.js";
+export { typography } from "./typography.js";
+export { widths } from "./widths.js";

package/packages/design-system/dist/tokens/index.js

@@ -0,0 +1,4 @@
+export * from "./colors.js";
+export { spacing } from "./spacing.js";
+export { typography } from "./typography.js";
+export { widths } from "./widths.js";

package/packages/design-system/dist/tokens/spacing.d.ts

@@ -0,0 +1,6 @@
+export declare const spacing: {
+    readonly sm: 1;
+    readonly md: 2;
+    readonly lg: 4;
+    readonly xl: 8;
+};

package/packages/design-system/dist/tokens/spacing.js

@@ -0,0 +1,6 @@
+export const spacing = {
+    sm: 1,
+    md: 2,
+    lg: 4,
+    xl: 8
+};

package/packages/design-system/dist/tokens/typography.d.ts

@@ -0,0 +1,7 @@
+export declare const typography: {
+    readonly bold: (text: string) => string;
+    readonly dim: (text: string) => string;
+    readonly italic: (text: string) => string;
+    readonly underline: (text: string) => string;
+    readonly strikethrough: (text: string) => string;
+};

package/packages/design-system/dist/tokens/typography.js

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+export const typography = {
+    bold: (text) => chalk.bold(text),
+    dim: (text) => chalk.dim(text),
+    italic: (text) => chalk.italic(text),
+    underline: (text) => chalk.underline(text),
+    strikethrough: (text) => chalk.strikethrough(text)
+};

package/packages/design-system/dist/tokens/widths.d.ts

@@ -0,0 +1,5 @@
+export declare const widths: {
+    readonly header: 60;
+    readonly helpColumn: 24;
+    readonly maxLine: 80;
+};

package/packages/design-system/dist/tokens/widths.js

@@ -0,0 +1,5 @@
+export const widths = {
+    header: 60,
+    helpColumn: 24,
+    maxLine: 80
+};

package/packages/tiny-stdio-mcp-server/dist/content/audio.d.ts

@@ -0,0 +1,14 @@
+export interface AudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+export declare class Audio {
+    private readonly base64Data;
+    private readonly mimeType;
+    private constructor();
+    static fromUrl(url: string): Promise<Audio>;
+    static fromBytes(data: Uint8Array, format?: string): Audio;
+    static fromBase64(base64: string, mimeType: string): Audio;
+    toContentBlock(): AudioContent;
+}

package/packages/tiny-stdio-mcp-server/dist/content/audio.js

@@ -0,0 +1,76 @@
+import { fileTypeFromBuffer } from "./mime.js";
+const SUPPORTED_AUDIO_MIMES = new Set([
+    "audio/mpeg",
+    "audio/wav",
+    "audio/ogg",
+    "audio/mp4",
+]);
+const AUDIO_FORMAT_MAP = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    m4a: "audio/mp4",
+    mpeg: "audio/mpeg",
+};
+export class Audio {
+    base64Data;
+    mimeType;
+    constructor(base64Data, mimeType) {
+        this.base64Data = base64Data;
+        this.mimeType = mimeType;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch audio from ${url}: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const data = new Uint8Array(arrayBuffer);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected && SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = response.headers.get("content-type")?.split(";")[0];
+            if (contentType && SUPPORTED_AUDIO_MIMES.has(contentType)) {
+                mimeType = contentType;
+            }
+            else {
+                throw new Error(`Unable to detect audio MIME type from ${url}`);
+            }
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Audio(base64, mimeType);
+    }
+    static fromBytes(data, format) {
+        let mimeType;
+        if (format) {
+            if (format.includes("/")) {
+                mimeType = format;
+            }
+            else {
+                mimeType = AUDIO_FORMAT_MAP[format.toLowerCase()] || `audio/${format}`;
+            }
+        }
+        else {
+            const detected = fileTypeFromBuffer(data);
+            if (!detected || !SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+                throw new Error("Unable to detect audio MIME type from bytes");
+            }
+            mimeType = detected.mime;
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Audio(base64, mimeType);
+    }
+    static fromBase64(base64, mimeType) {
+        return new Audio(base64, mimeType);
+    }
+    toContentBlock() {
+        return {
+            type: "audio",
+            data: this.base64Data,
+            mimeType: this.mimeType,
+        };
+    }
+}

package/packages/tiny-stdio-mcp-server/dist/content/convert.d.ts

@@ -0,0 +1,16 @@
+import { Image, type ImageContent } from "./image.js";
+import { Audio, type AudioContent } from "./audio.js";
+import { File, type EmbeddedResource } from "./file.js";
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export type ContentBlock = TextContent | ImageContent | AudioContent | EmbeddedResource;
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type ToolReturn = undefined | JsonPrimitive | JsonObject | Image | Audio | File | ContentBlock | Array<undefined | JsonPrimitive | JsonObject | Image | Audio | File | ContentBlock>;
+export declare function toContentBlocks(result: ToolReturn): ContentBlock[];
+export {};

package/packages/tiny-stdio-mcp-server/dist/content/convert.js

@@ -0,0 +1,42 @@
+import { Image } from "./image.js";
+import { Audio } from "./audio.js";
+import { File } from "./file.js";
+function convertSingleValue(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return { type: "text", text: String(value) };
+    }
+    if (value === null) {
+        return { type: "text", text: "null" };
+    }
+    if (value instanceof Image) {
+        return value.toContentBlock();
+    }
+    if (value instanceof Audio) {
+        return value.toContentBlock();
+    }
+    if (value instanceof File) {
+        return value.toContentBlock();
+    }
+    if (isContentBlock(value)) {
+        return value;
+    }
+    return { type: "text", text: JSON.stringify(value) };
+}
+export function toContentBlocks(result) {
+    if (result === undefined) {
+        return [];
+    }
+    if (Array.isArray(result)) {
+        return result.flatMap((item) => toContentBlocks(item));
+    }
+    return [convertSingleValue(result)];
+}
+function isContentBlock(value) {
+    if (!("type" in value) || typeof value.type !== "string") {
+        return false;
+    }
+    return (value.type === "text" ||
+        value.type === "image" ||
+        value.type === "audio" ||
+        value.type === "resource");
+}

package/packages/tiny-stdio-mcp-server/dist/content/file-type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal magic bytes detection for common media types.
+ * This can be replaced with `file-type` package (https://npm.im/file-type)
+ * if more comprehensive detection is needed. The API is designed to be
+ * compatible: fileTypeFromBuffer(data) returns { mime: string, ext: string } | undefined
+ */
+export interface FileTypeResult {
+    mime: string;
+    ext: string;
+}
+export declare function fileTypeFromBuffer(data: Uint8Array): FileTypeResult | undefined;

package/packages/tiny-stdio-mcp-server/dist/content/file-type.js

@@ -0,0 +1,93 @@
+/**
+ * Minimal magic bytes detection for common media types.
+ * This can be replaced with `file-type` package (https://npm.im/file-type)
+ * if more comprehensive detection is needed. The API is designed to be
+ * compatible: fileTypeFromBuffer(data) returns { mime: string, ext: string } | undefined
+ */
+export function fileTypeFromBuffer(data) {
+    if (data.length < 12) {
+        return undefined;
+    }
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (data[0] === 0x89 &&
+        data[1] === 0x50 &&
+        data[2] === 0x4e &&
+        data[3] === 0x47 &&
+        data[4] === 0x0d &&
+        data[5] === 0x0a &&
+        data[6] === 0x1a &&
+        data[7] === 0x0a) {
+        return { mime: "image/png", ext: "png" };
+    }
+    // JPEG: FF D8 FF
+    if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff) {
+        return { mime: "image/jpeg", ext: "jpg" };
+    }
+    // GIF: 47 49 46 38 (GIF8)
+    if (data[0] === 0x47 &&
+        data[1] === 0x49 &&
+        data[2] === 0x46 &&
+        data[3] === 0x38) {
+        return { mime: "image/gif", ext: "gif" };
+    }
+    // WEBP: 52 49 46 46 ... 57 45 42 50 (RIFF...WEBP)
+    if (data[0] === 0x52 &&
+        data[1] === 0x49 &&
+        data[2] === 0x46 &&
+        data[3] === 0x46 &&
+        data[8] === 0x57 &&
+        data[9] === 0x45 &&
+        data[10] === 0x42 &&
+        data[11] === 0x50) {
+        return { mime: "image/webp", ext: "webp" };
+    }
+    // MP3: FF FB or FF FA (MPEG audio) or 49 44 33 (ID3 tag)
+    if ((data[0] === 0xff && (data[1] === 0xfb || data[1] === 0xfa)) ||
+        (data[0] === 0x49 && data[1] === 0x44 && data[2] === 0x33)) {
+        return { mime: "audio/mpeg", ext: "mp3" };
+    }
+    // WAV: 52 49 46 46 ... 57 41 56 45 (RIFF...WAVE)
+    if (data[0] === 0x52 &&
+        data[1] === 0x49 &&
+        data[2] === 0x46 &&
+        data[3] === 0x46 &&
+        data[8] === 0x57 &&
+        data[9] === 0x41 &&
+        data[10] === 0x56 &&
+        data[11] === 0x45) {
+        return { mime: "audio/wav", ext: "wav" };
+    }
+    // OGG: 4F 67 67 53 (OggS)
+    if (data[0] === 0x4f &&
+        data[1] === 0x67 &&
+        data[2] === 0x67 &&
+        data[3] === 0x53) {
+        return { mime: "audio/ogg", ext: "ogg" };
+    }
+    // M4A: MP4 container with audio - check for M4A brand at offset 8
+    // ftyp followed by M4A brand
+    if (data[4] === 0x66 &&
+        data[5] === 0x74 &&
+        data[6] === 0x79 &&
+        data[7] === 0x70 &&
+        data[8] === 0x4d &&
+        data[9] === 0x34 &&
+        data[10] === 0x41) {
+        return { mime: "audio/mp4", ext: "m4a" };
+    }
+    // MP4: ... 66 74 79 70 (ftyp box, offset 4)
+    if (data[4] === 0x66 &&
+        data[5] === 0x74 &&
+        data[6] === 0x79 &&
+        data[7] === 0x70) {
+        return { mime: "video/mp4", ext: "mp4" };
+    }
+    // WEBM: 1A 45 DF A3 (EBML header)
+    if (data[0] === 0x1a &&
+        data[1] === 0x45 &&
+        data[2] === 0xdf &&
+        data[3] === 0xa3) {
+        return { mime: "video/webm", ext: "webm" };
+    }
+    return undefined;
+}

package/packages/tiny-stdio-mcp-server/dist/content/file.d.ts

@@ -0,0 +1,26 @@
+export interface TextResourceContents {
+    uri: string;
+    mimeType: string;
+    text: string;
+}
+export interface BlobResourceContents {
+    uri: string;
+    mimeType: string;
+    blob: string;
+}
+export interface EmbeddedResource {
+    type: "resource";
+    resource: TextResourceContents | BlobResourceContents;
+}
+export declare class File {
+    private readonly data;
+    private readonly mimeType;
+    private readonly isText;
+    private readonly name?;
+    private constructor();
+    static fromUrl(url: string): Promise<File>;
+    static fromBytes(data: Uint8Array, mimeType: string): File;
+    static fromText(text: string, mimeType?: string): File;
+    static fromBase64(base64: string, mimeType: string): File;
+    toContentBlock(): EmbeddedResource;
+}

package/packages/tiny-stdio-mcp-server/dist/content/file.js

@@ -0,0 +1,94 @@
+import { fileTypeFromBuffer } from "./mime.js";
+function isTextMimeType(mimeType) {
+    return (mimeType.startsWith("text/") ||
+        mimeType === "application/json" ||
+        mimeType === "application/xml" ||
+        mimeType === "application/javascript" ||
+        mimeType === "application/typescript");
+}
+export class File {
+    data;
+    mimeType;
+    isText;
+    name;
+    constructor(data, mimeType, isText, name) {
+        this.data = data;
+        this.mimeType = mimeType;
+        this.isText = isText;
+        this.name = name;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch file from ${url}: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const data = new Uint8Array(arrayBuffer);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = response.headers.get("content-type")?.split(";")[0];
+            if (contentType) {
+                mimeType = contentType;
+            }
+            else {
+                throw new Error(`Unable to detect MIME type from ${url}`);
+            }
+        }
+        const isText = isTextMimeType(mimeType);
+        const name = url.split("/").pop() || "file";
+        return new File(data, mimeType, isText, name);
+    }
+    static fromBytes(data, mimeType) {
+        const isText = isTextMimeType(mimeType);
+        return new File(data, mimeType, isText);
+    }
+    static fromText(text, mimeType = "text/plain") {
+        return new File(text, mimeType, true);
+    }
+    static fromBase64(base64, mimeType) {
+        const data = Buffer.from(base64, "base64");
+        const isText = isTextMimeType(mimeType);
+        return new File(new Uint8Array(data), mimeType, isText);
+    }
+    toContentBlock() {
+        const uri = this.name ? `file:///${this.name}` : "file:///data";
+        if (this.isText) {
+            let text;
+            if (typeof this.data === "string") {
+                text = this.data;
+            }
+            else {
+                text = new TextDecoder("utf-8").decode(this.data);
+            }
+            return {
+                type: "resource",
+                resource: {
+                    uri,
+                    mimeType: this.mimeType,
+                    text,
+                },
+            };
+        }
+        else {
+            let blob;
+            if (typeof this.data === "string") {
+                blob = Buffer.from(this.data).toString("base64");
+            }
+            else {
+                blob = Buffer.from(this.data).toString("base64");
+            }
+            return {
+                type: "resource",
+                resource: {
+                    uri,
+                    mimeType: this.mimeType,
+                    blob,
+                },
+            };
+        }
+    }
+}

package/packages/tiny-stdio-mcp-server/dist/content/image.d.ts

@@ -0,0 +1,14 @@
+export interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export declare class Image {
+    private readonly base64Data;
+    private readonly mimeType;
+    private constructor();
+    static fromUrl(url: string): Promise<Image>;
+    static fromBytes(data: Uint8Array, format?: string): Image;
+    static fromBase64(base64: string, mimeType: string): Image;
+    toContentBlock(): ImageContent;
+}

package/packages/tiny-stdio-mcp-server/dist/content/image.js

@@ -0,0 +1,64 @@
+import { fileTypeFromBuffer } from "./mime.js";
+const SUPPORTED_IMAGE_MIMES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+export class Image {
+    base64Data;
+    mimeType;
+    constructor(base64Data, mimeType) {
+        this.base64Data = base64Data;
+        this.mimeType = mimeType;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const data = new Uint8Array(arrayBuffer);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected && SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = response.headers.get("content-type")?.split(";")[0];
+            if (contentType && SUPPORTED_IMAGE_MIMES.has(contentType)) {
+                mimeType = contentType;
+            }
+            else {
+                throw new Error(`Unable to detect image MIME type from ${url}`);
+            }
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Image(base64, mimeType);
+    }
+    static fromBytes(data, format) {
+        let mimeType;
+        if (format) {
+            mimeType = format.includes("/") ? format : `image/${format}`;
+        }
+        else {
+            const detected = fileTypeFromBuffer(data);
+            if (!detected || !SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+                throw new Error("Unable to detect image MIME type from bytes");
+            }
+            mimeType = detected.mime;
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Image(base64, mimeType);
+    }
+    static fromBase64(base64, mimeType) {
+        return new Image(base64, mimeType);
+    }
+    toContentBlock() {
+        return {
+            type: "image",
+            data: this.base64Data,
+            mimeType: this.mimeType,
+        };
+    }
+}

package/packages/tiny-stdio-mcp-server/dist/content/index.d.ts

@@ -0,0 +1,5 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./mime.js";
+export { Image, type ImageContent } from "./image.js";
+export { Audio, type AudioContent } from "./audio.js";
+export { File, type EmbeddedResource, type TextResourceContents, type BlobResourceContents, } from "./file.js";
+export { toContentBlocks, type ContentBlock, type TextContent, type ToolReturn, } from "./convert.js";

package/packages/tiny-stdio-mcp-server/dist/content/index.js

@@ -0,0 +1,8 @@
+// MIME detection
+export { fileTypeFromBuffer } from "./mime.js";
+// Content helpers
+export { Image } from "./image.js";
+export { Audio } from "./audio.js";
+export { File, } from "./file.js";
+// Conversion utility
+export { toContentBlocks, } from "./convert.js";

package/packages/tiny-stdio-mcp-server/dist/content/mime.d.ts

@@ -0,0 +1 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./file-type.js";

package/packages/tiny-stdio-mcp-server/dist/content/mime.js

@@ -0,0 +1 @@
+export { fileTypeFromBuffer } from "./file-type.js";

package/packages/tiny-stdio-mcp-server/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createServer } from "./server.js";
+export type { Server } from "./server.js";
+export { defineSchema } from "./schema.js";
+export type { TypedSchema } from "./schema.js";
+export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, } from "./content/index.js";
+export type { ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, } from "./content/index.js";
+export type { ToolReturn } from "./content/index.js";
+export type { ServerOptions, ToolHandler, ToolDefinition, Tool, CallToolResult, HandleResult, ContentItem, JSONSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, } from "./types.js";
+export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

package/packages/tiny-stdio-mcp-server/dist/index.js

@@ -0,0 +1,7 @@
+// Server
+export { createServer } from "./server.js";
+// Schema
+export { defineSchema } from "./schema.js";
+// Content helpers
+export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, } from "./content/index.js";
+export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

package/packages/tiny-stdio-mcp-server/dist/jsonrpc.d.ts

@@ -0,0 +1,14 @@
+import type { JSONRPCRequest, JSONRPCError, JSONRPCNotification } from "./types.js";
+export interface ParseResult {
+    success: true;
+    request: JSONRPCRequest | JSONRPCNotification;
+    isNotification: boolean;
+}
+export interface ParseError {
+    success: false;
+    error: JSONRPCError;
+    id: string | number | null;
+}
+export declare function parseMessage(line: string): ParseResult | ParseError;
+export declare function formatSuccessResponse(id: string | number | null, result: unknown): string;
+export declare function formatErrorResponse(id: string | number | null, error: JSONRPCError): string;