hyacinth-ai 0.9.6

package/dist/runtime/config-schema.d.ts

@@ -0,0 +1,201 @@
+export interface FullConfig {
+    provider: {
+        active: string;
+        routeMode: 'auto' | 'manual';
+        enableThinking: boolean;
+        /** DeepSeek 缓存隔离 ID，区分同一 key 下不同产品的缓存池。默认 "hyacinth"。 */
+        userId?: string;
+        anthropic: {
+            model: string;
+            apiKeyEnv: string;
+        };
+        openai: {
+            model: string;
+            apiKeyEnv: string;
+        };
+        deepseek: {
+            model: string;
+            apiKeyEnv: string;
+        };
+        gemini: {
+            model: string;
+            apiKeyEnv: string;
+        };
+        local: {
+            model: string;
+            baseUrl: string;
+            /** 单次请求最大输出 token 数（推荐）。兼容旧键名 maxTokens。 */
+            maxOutputTokens?: number;
+            /** @deprecated 使用 maxOutputTokens */
+            maxTokens?: number;
+            modelKey?: string;
+            healthCheck: {
+                restartDelayMs: number;
+                intervalMs: number;
+                timeoutMs: number;
+                maxRetries: number;
+                startupTimeoutMs: number;
+            };
+        };
+    };
+    session: {
+        maxTurns: number;
+        maxContext: number;
+        maxMessages: number;
+    };
+    safety: {
+        dangerousTools: string[];
+        allowedTools: string[];
+        allowedCommands: string[];
+        requireConfirmation: boolean;
+    };
+    context: {
+        compressThreshold: number;
+        emergencyThreshold: number;
+        compressDepth: number;
+    };
+    schedule: {
+        heartbeatMs: number;
+        maxConcurrent: number;
+        taskTimeoutMs: number;
+        maxRecords: number;
+    };
+    resiliency: {
+        retry: {
+            maxRetries: number;
+            baseDelayMs: number;
+            maxDelayMs: number;
+        };
+        circuitBreaker: {
+            failureThreshold: number;
+            cooldownMs: number;
+        };
+        fallbackChain: string[];
+    };
+    agents: {
+        disabled: string[];
+        [agentName: string]: {
+            maxTurns?: number;
+            allowedTools?: string[];
+            collaborationMode?: 'delegate' | 'adversarial' | 'parallel';
+        } | string[] | undefined;
+    };
+    tools: {
+        disabled: string[];
+        resultBuffer: {
+            /** Whether to buffer large tool results to disk instead of injecting them directly. Default true. */
+            enabled: boolean;
+            /** Size threshold in bytes. Results larger than this are buffered. Default 16384 (16 KB). */
+            threshold: number;
+            /** Include a preview of the first N characters in the pointer message. Default true. */
+            includePreview: boolean;
+            /** Number of characters to include in preview. Default 500. */
+            previewChars: number;
+        };
+    };
+    skills: {
+        disabled: string[];
+    };
+    models: {
+        assessment: {
+            source: 'main' | 'local';
+            model?: string;
+        };
+        planning: {
+            source: 'main' | 'local';
+            model?: string;
+        };
+        compression: {
+            source: 'main' | 'local';
+            model?: string;
+        };
+    };
+    local: {
+        baseUrl: string;
+        defaultModel: string;
+        /** 本地服务端口（默认 ollama=11434, llamacpp=8080） */
+        port: number;
+        /** 单次请求最大输出 token 数（推荐）。兼容旧键名 maxTokens。 */
+        maxOutputTokens?: number;
+        /** @deprecated 使用 maxOutputTokens */
+        maxTokens?: number;
+        /** 后端类型：ollama | llamacpp。未配置时从 baseUrl 端口自动推断 */
+        backend?: 'ollama' | 'llamacpp';
+    };
+    logging: {
+        level: 'debug' | 'info' | 'warn' | 'error' | 'off';
+        /** 是否在 stats.json 中记录每轮上下文缓存的命中详情。默认 false（调试用途）。 */
+        logCacheHits: boolean;
+    };
+    repair: {
+        scavenge: {
+            enabled: boolean;
+        };
+        storm: {
+            enabled: boolean;
+            windowSize: number;
+            threshold: number;
+            stormExemptTools: string[];
+        };
+        textLoop: {
+            enabled: boolean;
+            windowSize: number;
+            threshold: number;
+            similarity: number;
+            minLength: number;
+        };
+    };
+    hotReload: {
+        enabled: boolean;
+        debounceMs: number;
+        watchMcp: boolean;
+        watchPlugins: boolean;
+        watchPrompts: boolean;
+        watchAgents: boolean;
+        watchConfig: boolean;
+        watchTools: boolean;
+        watchSkills: boolean;
+        watchProviders: boolean;
+        watchModelCatalog: boolean;
+    };
+    memory?: {
+        conversationFile?: string;
+        eventsFile?: string;
+        statsFile?: string;
+        summaryFile?: string;
+        sessionDir?: string;
+    };
+    kb?: {
+        enabled: boolean;
+        zone4: boolean;
+        /** 检索最大返回条数（默认 5） */
+        maxTotal?: number;
+        /** 主要结果最大条数，展示完整内容（默认 3） */
+        maxMain?: number;
+        /** 补充引用最大条数，仅展示摘要（默认 2） */
+        maxRefs?: number;
+    };
+    /** 启动行为 */
+    startup?: {
+        /** 启动时默认进入的模式。'normal' = 普通模式（默认），'companion' = 陪伴模式 */
+        defaultMode: 'normal' | 'companion';
+    };
+    bypass?: {
+        /** 普通模式下是否启用上下文编排旁路Agent（默认 true） */
+        orchestratorEnabled: boolean;
+    };
+    diagnostics?: {
+        /** 代码修改后是否自动运行类型检查/编译检查。默认 true */
+        enabled: boolean;
+        /** 诊断命令超时时间（毫秒）。默认 15000 */
+        timeout: number;
+    };
+}
+export interface ConfigSchemaEntry {
+    path: string;
+    type: string;
+    description: string;
+    defaultValue: unknown;
+    currentValue: unknown;
+}
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/runtime/config-schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config-schema.js.map

package/dist/runtime/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { FullConfig } from './config-schema.js';
+export declare function getDefaultConfig(): FullConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/runtime/defaults.js

@@ -0,0 +1,146 @@
+import { getLocalProviderConfigLoader } from '../provider/local-config.js';
+import { DEFAULT_PROVIDERS, getProviderConfigLoader } from '../provider/config.js';
+import { DEFAULT_USER_ID } from '../provider/user-id.js';
+function providerDefault(providerId) {
+    try {
+        const loader = getProviderConfigLoader();
+        const meta = loader.getProvider(providerId);
+        if (meta?.defaultModel)
+            return meta.defaultModel;
+    }
+    catch { }
+    return DEFAULT_PROVIDERS.providers[providerId]?.defaultModel ?? 'unknown';
+}
+export function getDefaultConfig() {
+    const localCfg = getLocalProviderConfigLoader();
+    return {
+        provider: {
+            active: 'anthropic',
+            routeMode: 'auto',
+            enableThinking: false,
+            userId: DEFAULT_USER_ID,
+            anthropic: { model: providerDefault('anthropic'), apiKeyEnv: 'ANTHROPIC_API_KEY' },
+            openai: { model: providerDefault('openai'), apiKeyEnv: 'OPENAI_API_KEY' },
+            deepseek: { model: providerDefault('deepseek'), apiKeyEnv: 'DEEPSEEK_API_KEY' },
+            gemini: { model: providerDefault('gemini'), apiKeyEnv: 'GEMINI_API_KEY' },
+            local: {
+                model: localCfg.defaultModel,
+                baseUrl: localCfg.baseUrl,
+                maxOutputTokens: localCfg.maxOutputTokens,
+                healthCheck: {
+                    restartDelayMs: 3000,
+                    intervalMs: 5000,
+                    timeoutMs: 5000,
+                    maxRetries: 6,
+                    startupTimeoutMs: 120000,
+                },
+            },
+        },
+        session: {
+            maxTurns: 100,
+            maxContext: 200000,
+            maxMessages: 10000,
+        },
+        safety: {
+            dangerousTools: ['write', 'bash'],
+            allowedTools: [],
+            allowedCommands: [],
+            requireConfirmation: true,
+        },
+        context: {
+            compressThreshold: 0.75,
+            emergencyThreshold: 0.92,
+            compressDepth: 0.5,
+        },
+        schedule: {
+            heartbeatMs: 5000,
+            maxConcurrent: 10,
+            taskTimeoutMs: 300000,
+            maxRecords: 1000,
+        },
+        resiliency: {
+            retry: { maxRetries: 4, baseDelayMs: 1000, maxDelayMs: 30000 },
+            circuitBreaker: { failureThreshold: 5, cooldownMs: 30000 },
+            fallbackChain: [],
+        },
+        agents: { disabled: [] },
+        tools: {
+            disabled: [],
+            resultBuffer: {
+                enabled: true,
+                threshold: 16384, // 16 KB
+                includePreview: true,
+                previewChars: 500,
+            },
+        },
+        skills: { disabled: [] },
+        models: {
+            assessment: { source: 'main' },
+            planning: { source: 'main' },
+            compression: { source: 'main' },
+        },
+        local: {
+            baseUrl: localCfg.baseUrl,
+            defaultModel: localCfg.defaultModel,
+            port: localCfg.port,
+            maxTokens: localCfg.maxTokens,
+            backend: localCfg.backend,
+        },
+        logging: { level: 'info', logCacheHits: false },
+        repair: {
+            scavenge: {
+                enabled: true,
+            },
+            storm: {
+                enabled: true,
+                windowSize: 6,
+                threshold: 3,
+                stormExemptTools: [],
+            },
+            textLoop: {
+                enabled: true,
+                windowSize: 6,
+                threshold: 3,
+                similarity: 0.90,
+                minLength: 30,
+            },
+        },
+        hotReload: {
+            enabled: true,
+            debounceMs: 500,
+            watchMcp: true,
+            watchPlugins: true,
+            watchPrompts: true,
+            watchAgents: true,
+            watchConfig: true,
+            watchTools: true,
+            watchSkills: true,
+            watchProviders: true,
+            watchModelCatalog: true,
+        },
+        memory: {
+            conversationFile: 'conversation.jsonl',
+            eventsFile: 'events.jsonl',
+            statsFile: 'stats.json',
+            summaryFile: 'summary.md',
+        },
+        kb: {
+            enabled: false,
+            zone4: false,
+            maxTotal: 5,
+            maxMain: 3,
+            maxRefs: 2,
+        },
+        startup: {
+            defaultMode: 'normal',
+        },
+        bypass: {
+            orchestratorEnabled: true,
+        },
+        diagnostics: {
+            enabled: true,
+            timeout: 15000,
+        },
+    };
+}
+//# sourceMappingURL=defaults.js.map

package/dist/schedule/cron.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CronExpression — 5-field standard cron expression parser.
+ *
+ * Fields: minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Supports: * (all), N (exact), N-M (range), N,M (list), step-N (every N)
+ */
+export declare class CronExpression {
+    private minute;
+    private hour;
+    private dayOfMonth;
+    private month;
+    private dayOfWeek;
+    constructor(expression: string);
+    /** 计算指定时间之后的下一次执行时间 */
+    next(from?: Date): Date | null;
+    /** 计算指定时间之后的多次执行时间 */
+    nextN(from: Date, count: number): Date[];
+    /** 检查给定时间是否匹配 cron 表达式 */
+    private matches;
+    /** 解析一个 cron 字段 */
+    private parseField;
+    private range;
+}
+//# sourceMappingURL=cron.d.ts.map

package/dist/schedule/cron.js

@@ -0,0 +1,145 @@
+/**
+ * CronExpression — 5-field standard cron expression parser.
+ *
+ * Fields: minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Supports: * (all), N (exact), N-M (range), N,M (list), step-N (every N)
+ */
+export class CronExpression {
+    minute;
+    hour;
+    dayOfMonth;
+    month;
+    dayOfWeek;
+    constructor(expression) {
+        const parts = expression.trim().split(/\s+/);
+        if (parts.length !== 5) {
+            throw new Error(`Invalid cron expression: expected 5 fields, got ${parts.length}: "${expression}"`);
+        }
+        this.minute = this.parseField(parts[0], 0, 59);
+        this.hour = this.parseField(parts[1], 0, 23);
+        this.dayOfMonth = this.parseField(parts[2], 1, 31);
+        this.month = this.parseField(parts[3], 1, 12);
+        this.dayOfWeek = this.parseField(parts[4], 0, 6);
+    }
+    /** 计算指定时间之后的下一次执行时间 */
+    next(from = new Date()) {
+        // 从下一分钟开始检查
+        let candidate = new Date(from);
+        candidate.setSeconds(0, 0);
+        candidate.setMinutes(candidate.getMinutes() + 1);
+        const maxIterations = 525600; // 最多往前算一年
+        for (let i = 0; i < maxIterations; i++) {
+            if (this.matches(candidate)) {
+                return candidate;
+            }
+            candidate.setMinutes(candidate.getMinutes() + 1);
+        }
+        return null;
+    }
+    /** 计算指定时间之后的多次执行时间 */
+    nextN(from, count) {
+        const results = [];
+        let current = from;
+        for (let i = 0; i < count; i++) {
+            const n = this.next(current);
+            if (!n)
+                break;
+            results.push(n);
+            current = n;
+        }
+        return results;
+    }
+    /** 检查给定时间是否匹配 cron 表达式 */
+    matches(date) {
+        const m = date.getMinutes();
+        const h = date.getHours();
+        const d = date.getDate();
+        const mo = date.getMonth() + 1;
+        const dw = date.getDay();
+        if (!this.minute.includes(m))
+            return false;
+        if (!this.hour.includes(h))
+            return false;
+        if (!this.month.includes(mo))
+            return false;
+        // 日和周：如果两者都不是 *，则满足任一即可
+        const isDayAll = this.dayOfMonth.length === 60; // 0-59 全覆盖
+        const isWeekAll = this.dayOfWeek.length === 7; // 0-6 全覆盖
+        if (!isDayAll && !isWeekAll) {
+            return this.dayOfMonth.includes(d) || this.dayOfWeek.includes(dw);
+        }
+        if (!isDayAll && !this.dayOfMonth.includes(d))
+            return false;
+        if (!isWeekAll && !this.dayOfWeek.includes(dw))
+            return false;
+        return true;
+    }
+    /** 解析一个 cron 字段 */
+    parseField(field, min, max) {
+        if (field === '*') {
+            return this.range(min, max);
+        }
+        const values = new Set();
+        // 逗号分隔列表
+        for (const part of field.split(',')) {
+            const trimmed = part.trim();
+            if (trimmed.includes('/')) {
+                // 步进：*/N 或 N-M/N
+                const [rangePart, stepPart] = trimmed.split('/');
+                const step = parseInt(stepPart, 10);
+                if (isNaN(step) || step < 1)
+                    continue;
+                let rMin, rMax;
+                if (rangePart === '*') {
+                    rMin = min;
+                    rMax = max;
+                }
+                else if (rangePart.includes('-')) {
+                    const [s, e] = rangePart.split('-');
+                    rMin = parseInt(s, 10);
+                    rMax = parseInt(e, 10);
+                }
+                else {
+                    rMin = parseInt(rangePart, 10);
+                    rMax = max;
+                }
+                if (isNaN(rMin) || isNaN(rMax))
+                    continue;
+                for (let v = rMin; v <= rMax; v += step) {
+                    if (v >= min && v <= max)
+                        values.add(v);
+                }
+            }
+            else if (trimmed.includes('-')) {
+                // 范围 N-M
+                const [s, e] = trimmed.split('-');
+                const start = parseInt(s, 10);
+                const end = parseInt(e, 10);
+                if (isNaN(start) || isNaN(end))
+                    continue;
+                for (let v = start; v <= end; v++) {
+                    if (v >= min && v <= max)
+                        values.add(v);
+                }
+            }
+            else {
+                // 单个值
+                const v = parseInt(trimmed, 10);
+                if (!isNaN(v) && v >= min && v <= max) {
+                    values.add(v);
+                }
+            }
+        }
+        if (values.size === 0) {
+            throw new Error(`Invalid cron field "${field}" (range ${min}-${max})`);
+        }
+        return [...values].sort((a, b) => a - b);
+    }
+    range(min, max) {
+        const result = [];
+        for (let i = min; i <= max; i++)
+            result.push(i);
+        return result;
+    }
+}
+//# sourceMappingURL=cron.js.map

package/dist/schedule/index.d.ts

@@ -0,0 +1,6 @@
+export { CronExpression } from './cron.js';
+export { HeartbeatScheduler } from './scheduler.js';
+export { SchedulePersistence } from './persistence.js';
+export type { ScheduledTask, ScheduleType, ScheduleConfig, IntervalConfig, CronConfig, DailyConfig, FixedTimeConfig, TaskAction, TaskExecutionRecord, SchedulerConfig, SchedulerStatus, SerializedSchedulerData, } from './types.js';
+export type { TaskHandler } from './scheduler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schedule/index.js

@@ -0,0 +1,4 @@
+export { CronExpression } from './cron.js';
+export { HeartbeatScheduler } from './scheduler.js';
+export { SchedulePersistence } from './persistence.js';
+//# sourceMappingURL=index.js.map

package/dist/schedule/persistence.d.ts

@@ -0,0 +1,33 @@
+import type { ScheduledTask, TaskExecutionRecord, SerializedSchedulerData } from './types.js';
+/**
+ * SchedulePersistence — 定时任务的持久化存储。
+ *
+ * 职责：
+ *   1. 保存/加载任务列表
+ *   2. 保存/加载执行记录
+ *   3. 自动去重和容量控制
+ */
+export declare class SchedulePersistence {
+    private storagePath;
+    private data;
+    constructor();
+    /** 从磁盘加载数据 */
+    load(): Promise<SerializedSchedulerData>;
+    /** 保存到磁盘 */
+    private save;
+    /** 获取所有任务 */
+    getAllTasks(): Promise<ScheduledTask[]>;
+    /** 添加或更新任务 */
+    saveTask(task: ScheduledTask): Promise<void>;
+    /** 删除任务 */
+    deleteTask(taskId: string): Promise<boolean>;
+    /** 获取任务 */
+    getTask(taskId: string): Promise<ScheduledTask | null>;
+    /** 添加执行记录（自动裁剪到 maxRecords） */
+    addRecord(record: TaskExecutionRecord, maxRecords?: number): Promise<void>;
+    /** 获取最近的执行记录 */
+    getRecentRecords(limit?: number): Promise<TaskExecutionRecord[]>;
+    /** 清空所有数据 */
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=persistence.d.ts.map

package/dist/schedule/persistence.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const CACHE_VERSION = 1;
+/** 获取持久化文件路径 */
+function getStoragePath() {
+    return path.join(os.homedir(), '.agent', 'scheduler', 'tasks.json');
+}
+/**
+ * SchedulePersistence — 定时任务的持久化存储。
+ *
+ * 职责：
+ *   1. 保存/加载任务列表
+ *   2. 保存/加载执行记录
+ *   3. 自动去重和容量控制
+ */
+export class SchedulePersistence {
+    storagePath;
+    data = null;
+    constructor() {
+        this.storagePath = getStoragePath();
+    }
+    /** 从磁盘加载数据 */
+    async load() {
+        if (this.data)
+            return this.data;
+        try {
+            const content = await fs.readFile(this.storagePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (parsed.version === CACHE_VERSION) {
+                this.data = parsed;
+                return parsed;
+            }
+        }
+        catch {
+            // 不存在或不兼容，使用默认值
+        }
+        this.data = { version: CACHE_VERSION, tasks: [], records: [] };
+        return this.data;
+    }
+    /** 保存到磁盘 */
+    async save() {
+        if (!this.data)
+            return;
+        try {
+            const dir = path.dirname(this.storagePath);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(this.storagePath, JSON.stringify(this.data, null, 2), 'utf-8');
+        }
+        catch {
+            // 写入失败不影响主流程
+        }
+    }
+    /** 获取所有任务 */
+    async getAllTasks() {
+        const data = await this.load();
+        return data.tasks;
+    }
+    /** 添加或更新任务 */
+    async saveTask(task) {
+        const data = await this.load();
+        const idx = data.tasks.findIndex(t => t.id === task.id);
+        if (idx >= 0) {
+            data.tasks[idx] = task;
+        }
+        else {
+            data.tasks.push(task);
+        }
+        await this.save();
+    }
+    /** 删除任务 */
+    async deleteTask(taskId) {
+        const data = await this.load();
+        const idx = data.tasks.findIndex(t => t.id === taskId);
+        if (idx < 0)
+            return false;
+        data.tasks.splice(idx, 1);
+        await this.save();
+        return true;
+    }
+    /** 获取任务 */
+    async getTask(taskId) {
+        const data = await this.load();
+        return data.tasks.find(t => t.id === taskId) ?? null;
+    }
+    /** 添加执行记录（自动裁剪到 maxRecords） */
+    async addRecord(record, maxRecords = 1000) {
+        const data = await this.load();
+        data.records.unshift(record);
+        if (data.records.length > maxRecords) {
+            data.records = data.records.slice(0, maxRecords);
+        }
+        await this.save();
+    }
+    /** 获取最近的执行记录 */
+    async getRecentRecords(limit = 20) {
+        const data = await this.load();
+        return data.records.slice(0, limit);
+    }
+    /** 清空所有数据 */
+    async clear() {
+        this.data = { version: CACHE_VERSION, tasks: [], records: [] };
+        await this.save();
+    }
+}
+//# sourceMappingURL=persistence.js.map