hyacinth-ai 0.9.6

package/dist/memory/stats.d.ts

@@ -0,0 +1,23 @@
+import type { SessionStats } from '../types.js';
+export declare class StatsManager {
+    private readonly statsFile;
+    constructor(statsFile?: string);
+    private getFilePath;
+    /**
+     * 初始化 stats.json
+     */
+    init(sessionDir: string): Promise<void>;
+    /**
+     * 更新指定字段
+     */
+    update(sessionDir: string, updates: Partial<SessionStats>): Promise<void>;
+    /**
+     * 读取当前 stats
+     */
+    get(sessionDir: string): Promise<SessionStats>;
+    /**
+     * 增加指定字段
+     */
+    increment(sessionDir: string, field: keyof SessionStats, value?: number): Promise<void>;
+}
+//# sourceMappingURL=stats.d.ts.map

package/dist/memory/stats.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const DEFAULT_STATS = {
+    input_tokens: 0,
+    output_tokens: 0,
+    turn_count: 0,
+    compact_count: 0,
+    current_context_tokens: 0,
+};
+export class StatsManager {
+    statsFile;
+    constructor(statsFile = 'stats.json') {
+        this.statsFile = statsFile;
+    }
+    getFilePath(sessionDir) {
+        return path.join(sessionDir, this.statsFile);
+    }
+    /**
+     * 初始化 stats.json
+     */
+    async init(sessionDir) {
+        const filePath = this.getFilePath(sessionDir);
+        await fs.writeFile(filePath, JSON.stringify(DEFAULT_STATS, null, 2), 'utf-8');
+    }
+    /**
+     * 更新指定字段
+     */
+    async update(sessionDir, updates) {
+        const current = await this.get(sessionDir);
+        const merged = { ...current, ...updates };
+        const filePath = this.getFilePath(sessionDir);
+        await fs.writeFile(filePath, JSON.stringify(merged, null, 2), 'utf-8');
+    }
+    /**
+     * 读取当前 stats
+     */
+    async get(sessionDir) {
+        const filePath = this.getFilePath(sessionDir);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return { ...DEFAULT_STATS };
+        }
+    }
+    /**
+     * 增加指定字段
+     */
+    async increment(sessionDir, field, value = 1) {
+        const current = await this.get(sessionDir);
+        const currentValue = current[field];
+        // SessionStats 的所有字段都是 number 类型
+        current[field] = currentValue + value;
+        const filePath = this.getFilePath(sessionDir);
+        await fs.writeFile(filePath, JSON.stringify(current, null, 2), 'utf-8');
+    }
+}
+//# sourceMappingURL=stats.js.map

package/dist/memory/summary.d.ts

@@ -0,0 +1,7 @@
+export declare class SummaryStore {
+    private readonly summaryFile;
+    constructor(summaryFile?: string);
+    save(sessionDir: string, summary: string): Promise<void>;
+    load(sessionDir: string): Promise<string | null>;
+}
+//# sourceMappingURL=summary.d.ts.map

package/dist/memory/summary.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class SummaryStore {
+    summaryFile;
+    constructor(summaryFile = 'summary.md') {
+        this.summaryFile = summaryFile;
+    }
+    async save(sessionDir, summary) {
+        const filePath = path.join(sessionDir, this.summaryFile);
+        await fs.writeFile(filePath, summary, 'utf-8');
+    }
+    async load(sessionDir) {
+        const filePath = path.join(sessionDir, this.summaryFile);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=summary.js.map

package/dist/multimodal/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 多模态/图片管线 — 用户输入图片检测、压缩、索引、回收
+ */
+import type { MessageContent } from '../types.js';
+export declare const IMAGE_MIME_MAP: Record<string, string>;
+interface ImageRecord {
+    data: string;
+    media_type: string;
+    source_path: string;
+    description: string;
+    byteSize: number;
+    indexedAt: string;
+}
+export declare class ImageStore {
+    private images;
+    private _hashIndex;
+    private _cachedList;
+    private _dirty;
+    private nextSeq;
+    private _contentHash;
+    store(base64Data: string, mediaType: string, sourcePath?: string): string;
+    get(id: string): ImageRecord | null;
+    setDescription(id: string, desc: string): void;
+    list(): {
+        id: string;
+        media_type: string;
+        description: string;
+        byteSize: number;
+        source_path: string;
+        indexedAt: string;
+    }[];
+    listForContext(): string;
+}
+export declare function compressImageIfLarge(buf: Buffer, mime: string): Promise<{
+    buffer: Buffer;
+    mime: string;
+    compressed: boolean;
+}>;
+export declare function detectImagePaths(text: string): string[];
+/** 渠道图片：接受已下载的 base64 数据，直接构造 ImageContent */
+export declare function buildUserContentWithInlineImages(userInput: string, images: Array<{
+    data: string;
+    media_type: string;
+}>, imageStore: ImageStore): MessageContent | MessageContent[];
+export declare function buildUserContentWithImages(userInput: string, imageStore: ImageStore): Promise<MessageContent | MessageContent[]>;
+export declare function createViewImageTool(imageStore: ImageStore, pendingInjections: Array<{
+    imgId: string;
+    data: string;
+    media_type: string;
+}>): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            image_id: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: never[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/multimodal/index.js

@@ -0,0 +1,210 @@
+/**
+ * 多模态/图片管线 — 用户输入图片检测、压缩、索引、回收
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+// ── MIME 映射 ───────────────────────────────────────────────────────
+export const IMAGE_MIME_MAP = {
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+    gif: 'image/gif', webp: 'image/webp', bmp: 'image/bmp',
+    svg: 'image/svg+xml', ico: 'image/x-icon', tif: 'image/tiff', tiff: 'image/tiff',
+};
+export class ImageStore {
+    images = new Map();
+    _hashIndex = new Map();
+    _cachedList = '';
+    _dirty = true;
+    nextSeq = 1;
+    _contentHash(base64Data, mediaType) {
+        const head = base64Data.slice(0, 512);
+        const tail = base64Data.slice(-512);
+        return `${mediaType}:${base64Data.length}:${head.length}:${tail.length}`;
+    }
+    store(base64Data, mediaType, sourcePath) {
+        const hash = this._contentHash(base64Data, mediaType);
+        const existing = this._hashIndex.get(hash);
+        if (existing)
+            return existing;
+        const id = `img_${String(this.nextSeq).padStart(3, '0')}`;
+        this.nextSeq++;
+        const decodedBytes = Math.ceil(base64Data.length * 0.75);
+        this.images.set(id, {
+            data: base64Data, media_type: mediaType,
+            source_path: sourcePath || '', description: '',
+            byteSize: decodedBytes, indexedAt: new Date().toISOString(),
+        });
+        this._hashIndex.set(hash, id);
+        this._dirty = true;
+        return id;
+    }
+    get(id) {
+        return this.images.get(id) ?? null;
+    }
+    setDescription(id, desc) {
+        const img = this.images.get(id);
+        if (img) {
+            img.description = desc;
+            this._dirty = true;
+        }
+    }
+    list() {
+        return [...this.images.entries()].map(([id, img]) => ({
+            id, media_type: img.media_type, description: img.description,
+            byteSize: img.byteSize, source_path: img.source_path, indexedAt: img.indexedAt,
+        }));
+    }
+    listForContext() {
+        if (!this._dirty)
+            return this._cachedList;
+        const undescribed = this.list().filter(e => !e.description);
+        if (undescribed.length === 0) {
+            this._cachedList = '';
+        }
+        else {
+            this._cachedList = undescribed.map(e => {
+                const sizeStr = e.byteSize < 1024 ? `${e.byteSize}B` : `${(e.byteSize / 1024).toFixed(1)}KB`;
+                return `[Image #${e.id}: ${e.media_type.split('/')[1]?.toUpperCase() || 'IMG'}, ${sizeStr} — view_image("${e.id}") to re-examine]`;
+            }).join('\n');
+        }
+        this._dirty = false;
+        return this._cachedList;
+    }
+}
+// ── 图片压缩 ────────────────────────────────────────────────────────
+export async function compressImageIfLarge(buf, mime) {
+    const MAX_DIM = 2048;
+    const COMPRESS_THRESHOLD = 300 * 1024;
+    if (buf.length <= COMPRESS_THRESHOLD)
+        return { buffer: buf, mime, compressed: false };
+    let sharp;
+    try {
+        // @ts-expect-error — sharp 0.35 types incompatible with pnpm exports
+        sharp = (await import('sharp')).default;
+    }
+    catch {
+        return { buffer: buf, mime, compressed: false };
+    }
+    try {
+        const image = sharp(buf);
+        const metadata = await image.metadata();
+        const longEdge = Math.max(metadata.width || 0, metadata.height || 0);
+        let pipeline = image;
+        if (longEdge > MAX_DIM) {
+            pipeline = pipeline.resize({ width: MAX_DIM, height: MAX_DIM, fit: 'inside', withoutEnlargement: true });
+        }
+        const hasAlpha = metadata.hasAlpha ?? false;
+        const outMime = (mime === 'image/png' && hasAlpha) ? 'image/png' : 'image/jpeg';
+        if (outMime === 'image/jpeg')
+            pipeline = pipeline.jpeg({ quality: 80 });
+        else
+            pipeline = pipeline.png({ quality: 80, palette: true });
+        const compressed = await pipeline.toBuffer();
+        return { buffer: compressed, mime: outMime, compressed: true };
+    }
+    catch {
+        return { buffer: buf, mime, compressed: false };
+    }
+}
+// ── 路径检测 ────────────────────────────────────────────────────────
+export function detectImagePaths(text) {
+    const paths = [];
+    // Match paths with image extensions. Allows spaces (stops at quotes/newlines).
+    // Windows: C:\..., Unix: /..., Relative: ./... or ../...
+    const pathRegex = /(?:["'`])?((?:[A-Za-z]:[^"'\n\r]*|(?:\/|\.\.?\/)[^"'\n\r]*)\.(?:png|jpe?g|gif|webp|bmp|svg|ico|tiff?))(?:["'`])?/gi;
+    let match;
+    while ((match = pathRegex.exec(text)) !== null) {
+        const p = match[1];
+        if (fs.existsSync(p) && fs.statSync(p).isFile())
+            paths.push(p);
+    }
+    return paths;
+}
+// ── 构建带图片的用户消息（渠道预取 inline base64）───────────────────
+/** 渠道图片：接受已下载的 base64 数据，直接构造 ImageContent */
+export function buildUserContentWithInlineImages(userInput, images, imageStore) {
+    if (images.length === 0)
+        return { type: 'text', text: userInput };
+    const blocks = [];
+    for (const img of images) {
+        const imgId = imageStore.store(img.data, img.media_type);
+        blocks.push({ type: 'image', source: { type: 'base64', media_type: img.media_type, data: img.data } });
+        const ext = img.media_type.split('/')[1]?.toUpperCase() || 'IMG';
+        const sizeStr = img.data.length < 700 ? `${img.data.length}B` : `${(img.data.length / 700).toFixed(1)}KB`;
+        blocks.push({ type: 'text', text: `[Image indexed as #${imgId}: ${ext}, ${sizeStr}]` });
+    }
+    blocks.push({ type: 'text', text: userInput });
+    return blocks;
+}
+// ── 构建带图片的用户消息（本地磁盘路径）─────────────────────────────
+export async function buildUserContentWithImages(userInput, imageStore) {
+    const imagePaths = detectImagePaths(userInput);
+    if (imagePaths.length === 0)
+        return { type: 'text', text: userInput };
+    const blocks = [];
+    const LARGE_BYTES = 500 * 1024;
+    for (const imgPath of imagePaths) {
+        const ext = path.extname(imgPath).toLowerCase().replace('.', '');
+        const mime = IMAGE_MIME_MAP[ext] || 'image/png';
+        try {
+            const stat = fs.statSync(imgPath);
+            let buf = (await fs.promises.readFile(imgPath));
+            let outMime = mime;
+            if (buf.length > LARGE_BYTES) {
+                const result = await compressImageIfLarge(buf, mime);
+                if (result.compressed) {
+                    buf = result.buffer;
+                    outMime = result.mime;
+                }
+            }
+            const b64 = buf.toString('base64');
+            const imgId = imageStore.store(b64, outMime, imgPath);
+            blocks.push({ type: 'image', source: { type: 'base64', media_type: outMime, data: b64 } });
+            const sizeStr = buf.length < 1024 ? `${buf.length}B` : `${(buf.length / 1024).toFixed(1)}KB`;
+            const estTokens = Math.ceil(b64.length * 0.75 / 4);
+            const warn = estTokens > 2000 ? ` ⚠️ ~${estTokens} tokens` : '';
+            blocks.push({ type: 'text', text: `[Image indexed as #${imgId}: ${ext.toUpperCase()}, ${sizeStr}${warn}]` });
+        }
+        catch {
+            blocks.push({ type: 'text', text: `[Failed to read image: ${imgPath}]` });
+        }
+    }
+    blocks.push({ type: 'text', text: userInput });
+    return blocks;
+}
+// ── view_image 工具 ──────────────────────────────────────────────────
+export function createViewImageTool(imageStore, pendingInjections) {
+    return {
+        name: 'view_image',
+        description: 'Re-examine a previously indexed image by its ID (e.g. "img_001"). Use this when you need to look at an image again for more details. The image will be injected into context on the next turn.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                image_id: { type: 'string', description: 'The image ID to re-examine (e.g. "img_001")' },
+            },
+            required: [],
+        },
+        async execute(args) {
+            const imgId = String(args.image_id || '').trim();
+            if (!imgId || imgId === 'list' || imgId === 'all') {
+                const entries = imageStore.list();
+                if (entries.length === 0)
+                    return 'No images indexed yet.';
+                return entries.map(e => {
+                    const sizeStr = e.byteSize < 1024 ? `${e.byteSize}B` : `${(e.byteSize / 1024).toFixed(1)}KB`;
+                    const desc = e.description ? ` — ${e.description.slice(0, 150)}` : '';
+                    return `#${e.id}: ${e.media_type.split('/')[1]?.toUpperCase() || 'IMG'}, ${sizeStr}${desc} (from ${e.source_path || 'unknown'})`;
+                }).join('\n');
+            }
+            const img = imageStore.get(imgId);
+            if (!img) {
+                const available = imageStore.list().map(i => i.id).join(', ') || '(none)';
+                return `Image #${imgId} not found. Available images: ${available}`;
+            }
+            pendingInjections.push({ imgId, data: img.data, media_type: img.media_type });
+            const sizeStr = img.byteSize < 1024 ? `${img.byteSize}B` : `${(img.byteSize / 1024).toFixed(1)}KB`;
+            const desc = img.description ? ` — ${img.description.slice(0, 200)}` : '';
+            return `[Image #${imgId} retrieved: ${img.media_type.split('/')[1]?.toUpperCase() || 'IMG'}, ${sizeStr}${desc}]\nThe image will be visible in the next response.`;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/orchestrator/index.d.ts

@@ -0,0 +1,5 @@
+export { AgentLoop } from './loop.js';
+export { LLMOrchestrator } from './planner.js';
+export { PlanStore, formatPlanAsText, createPlan } from './plan-store.js';
+export type { PlanStepStatus, PlanStatus, PlanStep, Plan } from './plan-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestrator/index.js

@@ -0,0 +1,4 @@
+export { AgentLoop } from './loop.js';
+export { LLMOrchestrator } from './planner.js';
+export { PlanStore, formatPlanAsText, createPlan } from './plan-store.js';
+//# sourceMappingURL=index.js.map