hyacinth-ai 0.9.6

package/dist/setup/model-defaults.js

@@ -0,0 +1,87 @@
+import { DEFAULT_MAX_CONTEXT_TOKENS } from './config.js';
+import { getModelCatalogLoader } from '../provider/model-catalog-loader.js';
+const PROVIDER_ALIAS = {
+    google: 'gemini',
+};
+function resolveProvider(provider) {
+    return PROVIDER_ALIAS[provider] ?? provider;
+}
+function buildProviderModels() {
+    const loader = getModelCatalogLoader();
+    const entries = loader.getAll();
+    const map = {};
+    const excludedIds = new Set(['__default__']);
+    for (const e of entries) {
+        if (excludedIds.has(e.id))
+            continue;
+        const p = e.provider;
+        if (!map[p])
+            map[p] = [];
+        map[p].push({
+            id: e.id,
+            name: e.name,
+            contextWindow: e.contextWindow,
+            maxOutputTokens: e.maxOutputTokens,
+            reasoning: e.reasoning,
+        });
+    }
+    return map;
+}
+let _providerModels = null;
+function getProviderModels() {
+    if (!_providerModels) {
+        _providerModels = buildProviderModels();
+    }
+    return _providerModels;
+}
+/** @deprecated 使用 ModelCatalogLoader 代替 */
+export const PROVIDER_MODELS = new Proxy({}, {
+    get(_target, prop) {
+        const resolved = resolveProvider(prop);
+        const models = getProviderModels();
+        return models[resolved] ?? models[prop];
+    },
+    ownKeys() {
+        return Reflect.ownKeys(getProviderModels());
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        const resolved = resolveProvider(prop);
+        const models = getProviderModels();
+        if (resolved in models) {
+            return { enumerable: true, configurable: true, value: models[resolved] };
+        }
+        if (prop in models) {
+            return { enumerable: true, configurable: true, value: models[prop] };
+        }
+        return undefined;
+    },
+});
+export function getModelContextWindow(provider, model) {
+    const resolved = resolveProvider(provider);
+    const loader = getModelCatalogLoader();
+    const entries = loader.getByProvider(resolved);
+    if (entries.length === 0)
+        return DEFAULT_MAX_CONTEXT_TOKENS;
+    if (model) {
+        const found = entries.find((m) => m.id === model);
+        if (found)
+            return found.contextWindow;
+    }
+    const firstNonDefault = entries.find((m) => m.id !== '__default__');
+    return firstNonDefault?.contextWindow ?? entries[0]?.contextWindow ?? DEFAULT_MAX_CONTEXT_TOKENS;
+}
+export function getModelMaxTokens(provider, model) {
+    const resolved = resolveProvider(provider);
+    const loader = getModelCatalogLoader();
+    const entries = loader.getByProvider(resolved);
+    if (entries.length === 0)
+        return 8192;
+    if (model) {
+        const found = entries.find((m) => m.id === model);
+        if (found)
+            return found.maxOutputTokens;
+    }
+    const firstNonDefault = entries.find((m) => m.id !== '__default__');
+    return firstNonDefault?.maxOutputTokens ?? entries[0]?.maxOutputTokens ?? 8192;
+}
+//# sourceMappingURL=model-defaults.js.map

package/dist/setup/persona-bootstrap.d.ts

@@ -0,0 +1,42 @@
+declare const PERSONA_FILE_NAMES: readonly ["BOOTSTRAP.md", "SOUL.md", "IDENTITY.md", "USER.md", "PartnerSoul.md", "PartnerMemory.md"];
+export type PersonaFileName = (typeof PERSONA_FILE_NAMES)[number];
+export type BootstrapStatus = 'pending' | 'complete';
+export interface PersonaState {
+    version: number;
+    bootstrapSeededAt?: string;
+    setupCompletedAt?: string;
+}
+export interface PersonaFile {
+    name: PersonaFileName;
+    path: string;
+    content?: string;
+    missing: boolean;
+}
+export interface PersonaValidationResult {
+    complete: boolean;
+    missing: PersonaFileName[];
+    templateFiles: PersonaFileName[];
+}
+export declare function getGlobalPersonaDir(configHome?: string): string;
+export declare const DEFAULT_PERSONA_DIR: string;
+export declare function ensurePersonaFiles(personaDir: string): Promise<{
+    status: BootstrapStatus;
+    filesCreated: string[];
+    state: PersonaState;
+}>;
+export declare function ensureGlobalPersonaFiles(configHome?: string): Promise<{
+    status: BootstrapStatus;
+    filesCreated: string[];
+    state: PersonaState;
+    personaDir: string;
+}>;
+export declare function validatePersonaFiles(personaDir: string): Promise<PersonaValidationResult>;
+export declare function validatePersonaFilesSync(personaDir: string): PersonaValidationResult;
+export declare function isBootstrapComplete(personaDir: string): Promise<boolean>;
+export declare function getBootstrapStatus(personaDir: string): Promise<BootstrapStatus>;
+export declare function markBootstrapComplete(personaDir: string): Promise<void>;
+export declare function markBootstrapCompleteSync(personaDir: string): void;
+export declare function loadPersonaFiles(personaDir: string, cwdFallback?: string): Promise<PersonaFile[]>;
+export declare function getPersonaState(personaDir: string): Promise<PersonaState>;
+export {};
+//# sourceMappingURL=persona-bootstrap.d.ts.map

package/dist/setup/persona-bootstrap.js

@@ -0,0 +1,379 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../logging/logger.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logger = createLogger('persona-bootstrap');
+// ─── Constants ──────────────────────────────────────────────────────
+const PERSONA_STATE_DIR = '.state';
+const PERSONA_STATE_FILE = 'persona-state.json';
+const PERSONA_STATE_VERSION = 1;
+const PERSONA_FILE_NAMES = [
+    'BOOTSTRAP.md',
+    'SOUL.md',
+    'IDENTITY.md',
+    'USER.md',
+    'PartnerSoul.md',
+    'PartnerMemory.md',
+];
+export function getGlobalPersonaDir(configHome = path.join(os.homedir(), '.agent')) {
+    return path.join(configHome, 'prompts', 'persona');
+}
+export const DEFAULT_PERSONA_DIR = getGlobalPersonaDir();
+// ─── Template Loading ───────────────────────────────────────────────
+function loadTemplateContent(fileName) {
+    const possibleDirs = [
+        path.join(__dirname, '..', 'prompts', 'persona'),
+        path.join(process.cwd(), 'src', 'prompts', 'persona'),
+        path.join(process.cwd(), 'dist', 'prompts', 'persona'),
+    ];
+    for (const dir of possibleDirs) {
+        const filePath = path.join(dir, fileName);
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Template not found: ${fileName}. Searched: ${possibleDirs.join(', ')}`);
+}
+// ─── State Management ────────────────────────────────────────────────
+function resolveStatePath(personaDir) {
+    return path.join(personaDir, PERSONA_STATE_DIR, PERSONA_STATE_FILE);
+}
+async function readState(personaDir) {
+    const statePath = resolveStatePath(personaDir);
+    try {
+        const raw = await fsp.readFile(statePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.version === PERSONA_STATE_VERSION) {
+            return parsed;
+        }
+        return { version: PERSONA_STATE_VERSION };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            return { version: PERSONA_STATE_VERSION };
+        }
+        throw err;
+    }
+}
+async function writeState(personaDir, state) {
+    const stateDir = path.join(personaDir, PERSONA_STATE_DIR);
+    await fsp.mkdir(stateDir, { recursive: true });
+    const statePath = resolveStatePath(personaDir);
+    await fsp.writeFile(statePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+// ─── File Operations ─────────────────────────────────────────────────
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fsp.writeFile(filePath, content, { encoding: 'utf-8', flag: 'wx' });
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EEXIST')
+            return false;
+        throw err;
+    }
+}
+async function fileContentDiffersFromTemplate(filePath, template) {
+    try {
+        const existing = await fsp.readFile(filePath, 'utf-8');
+        return existing !== template;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────
+export async function ensurePersonaFiles(personaDir) {
+    await fsp.mkdir(personaDir, { recursive: true });
+    let state = await readState(personaDir);
+    const now = new Date().toISOString();
+    // 自动补检测：如果 persona 文件已被填写（内容 ≠ 模板）但 state 文件未反映
+    //（例如 markBootstrapComplete 因格式验证过严而失败），
+    // 在重建 BOOTSTRAP.md 之前标记为完成。这是修复"每次启动都重新引导"的 bug。
+    if (!state.setupCompletedAt) {
+        try {
+            const identityPath = path.join(personaDir, 'IDENTITY.md');
+            const userPath = path.join(personaDir, 'USER.md');
+            const identityTemplate = loadTemplateContent('IDENTITY.md');
+            const userTemplate = loadTemplateContent('USER.md');
+            const identityChanged = await fileContentDiffersFromTemplate(identityPath, identityTemplate);
+            const userChanged = await fileContentDiffersFromTemplate(userPath, userTemplate);
+            if (identityChanged || userChanged) {
+                state = { ...state, setupCompletedAt: now };
+                logger.info('Persona setup auto-detected as complete (files already filled)');
+            }
+        }
+        catch {
+            // 文件可能尚未创建 — 正常继续
+        }
+    }
+    const alreadyComplete = !!state.setupCompletedAt;
+    const filesCreated = [];
+    for (const fileName of PERSONA_FILE_NAMES) {
+        if (alreadyComplete && fileName === 'BOOTSTRAP.md')
+            continue;
+        const filePath = path.join(personaDir, fileName);
+        const template = loadTemplateContent(fileName);
+        const created = await writeFileIfMissing(filePath, template);
+        if (created) {
+            filesCreated.push(fileName);
+            logger.info('Created persona file', { file: fileName, dir: personaDir });
+        }
+    }
+    const bootstrapPath = path.join(personaDir, 'BOOTSTRAP.md');
+    let bootstrapExists = true;
+    try {
+        await fsp.access(bootstrapPath);
+    }
+    catch {
+        bootstrapExists = false;
+    }
+    if (bootstrapExists && !state.bootstrapSeededAt) {
+        state = { ...state, bootstrapSeededAt: now };
+    }
+    if (!state.setupCompletedAt) {
+        const identityPath = path.join(personaDir, 'IDENTITY.md');
+        const userPath = path.join(personaDir, 'USER.md');
+        const identityTemplate = loadTemplateContent('IDENTITY.md');
+        const userTemplate = loadTemplateContent('USER.md');
+        const identityChanged = await fileContentDiffersFromTemplate(identityPath, identityTemplate);
+        const userChanged = await fileContentDiffersFromTemplate(userPath, userTemplate);
+        if ((identityChanged || userChanged) && !bootstrapExists) {
+            state = { ...state, setupCompletedAt: now };
+            logger.info('Persona setup detected as complete (user-modified files)');
+        }
+        else if (!bootstrapExists && state.bootstrapSeededAt && !state.setupCompletedAt) {
+            if (identityChanged || userChanged) {
+                state = { ...state, setupCompletedAt: now };
+                logger.info('Persona setup auto-completed (seeded + files modified + bootstrap deleted)');
+            }
+        }
+    }
+    await writeState(personaDir, state);
+    const status = state.setupCompletedAt ? 'complete' : 'pending';
+    return { status, filesCreated, state };
+}
+export async function ensureGlobalPersonaFiles(configHome) {
+    const personaDir = getGlobalPersonaDir(configHome);
+    const result = await ensurePersonaFiles(personaDir);
+    return { ...result, personaDir };
+}
+export async function validatePersonaFiles(personaDir) {
+    const missing = [];
+    const templateFiles = [];
+    for (const fileName of ['SOUL.md', 'IDENTITY.md', 'USER.md']) {
+        const filePath = path.join(personaDir, fileName);
+        let content;
+        try {
+            content = await fsp.readFile(filePath, 'utf-8');
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                missing.push(fileName);
+                continue;
+            }
+            throw err;
+        }
+        const template = loadTemplateContent(fileName);
+        if (content === template) {
+            templateFiles.push(fileName);
+            continue;
+        }
+        // 内容 ≠ 模板 → 视为已填写。不要求特定字段格式（如"名字:"等），
+        // 因为 bootstrap 对话中模型可能用不同格式书写，不应因此阻塞完成标记。
+    }
+    return {
+        complete: missing.length === 0 && templateFiles.length === 0,
+        missing,
+        templateFiles,
+    };
+}
+export function validatePersonaFilesSync(personaDir) {
+    const missing = [];
+    const templateFiles = [];
+    for (const fileName of ['SOUL.md', 'IDENTITY.md', 'USER.md']) {
+        const filePath = path.join(personaDir, fileName);
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                missing.push(fileName);
+                continue;
+            }
+            throw err;
+        }
+        const template = loadTemplateContent(fileName);
+        if (content === template) {
+            templateFiles.push(fileName);
+            continue;
+        }
+    }
+    return {
+        complete: missing.length === 0 && templateFiles.length === 0,
+        missing,
+        templateFiles,
+    };
+}
+export async function isBootstrapComplete(personaDir) {
+    const state = await readState(personaDir);
+    if (!state.setupCompletedAt)
+        return false;
+    const validation = await validatePersonaFiles(personaDir);
+    return validation.complete;
+}
+export async function getBootstrapStatus(personaDir) {
+    const state = await readState(personaDir);
+    if (state.setupCompletedAt) {
+        const validation = await validatePersonaFiles(personaDir);
+        return validation.complete ? 'complete' : 'pending';
+    }
+    const bootstrapPath = path.join(personaDir, 'BOOTSTRAP.md');
+    try {
+        await fsp.access(bootstrapPath);
+        return 'pending';
+    }
+    catch {
+        return 'complete';
+    }
+}
+export async function markBootstrapComplete(personaDir) {
+    const validation = await validatePersonaFiles(personaDir);
+    if (!validation.complete) {
+        const details = [
+            validation.missing.length > 0 ? `missing: ${validation.missing.join(', ')}` : '',
+            validation.templateFiles.length > 0 ? `templates: ${validation.templateFiles.join(', ')}` : '',
+        ].filter(Boolean).join('; ');
+        throw new Error(`Persona bootstrap is incomplete${details ? ` (${details})` : ''}.`);
+    }
+    const bootstrapPath = path.join(personaDir, 'BOOTSTRAP.md');
+    try {
+        await fsp.unlink(bootstrapPath);
+        logger.info('Deleted BOOTSTRAP.md');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT')
+            throw err;
+    }
+    const state = await readState(personaDir);
+    state.setupCompletedAt = new Date().toISOString();
+    await writeState(personaDir, state);
+    logger.info('Bootstrap marked as complete');
+}
+export function markBootstrapCompleteSync(personaDir) {
+    const validation = validatePersonaFilesSync(personaDir);
+    if (!validation.complete) {
+        const details = [
+            validation.missing.length > 0 ? `missing: ${validation.missing.join(', ')}` : '',
+            validation.templateFiles.length > 0 ? `templates: ${validation.templateFiles.join(', ')}` : '',
+        ].filter(Boolean).join('; ');
+        throw new Error(`Persona bootstrap is incomplete${details ? ` (${details})` : ''}.`);
+    }
+    const bootstrapPath = path.join(personaDir, 'BOOTSTRAP.md');
+    try {
+        fs.unlinkSync(bootstrapPath);
+        logger.info('Deleted BOOTSTRAP.md');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT')
+            throw err;
+    }
+    const state = readStateSync(personaDir);
+    state.setupCompletedAt = new Date().toISOString();
+    writeStateSync(personaDir, state);
+    logger.info('Bootstrap marked as complete');
+}
+function readStateSync(personaDir) {
+    const statePath = resolveStatePath(personaDir);
+    try {
+        const raw = fs.readFileSync(statePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.version === PERSONA_STATE_VERSION) {
+            return parsed;
+        }
+        return { version: PERSONA_STATE_VERSION };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return { version: PERSONA_STATE_VERSION };
+        throw err;
+    }
+}
+function writeStateSync(personaDir, state) {
+    const stateDir = path.join(personaDir, PERSONA_STATE_DIR);
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(resolveStatePath(personaDir), JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+export async function loadPersonaFiles(personaDir, cwdFallback) {
+    const files = [];
+    for (const fileName of PERSONA_FILE_NAMES) {
+        const filePath = path.join(personaDir, fileName);
+        try {
+            const content = await fsp.readFile(filePath, 'utf-8');
+            files.push({ name: fileName, path: filePath, content, missing: false });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                if (cwdFallback) {
+                    const cwdPath = path.join(cwdFallback, fileName);
+                    try {
+                        const cwdContent = await fsp.readFile(cwdPath, 'utf-8');
+                        files.push({ name: fileName, path: cwdPath, content: cwdContent, missing: false });
+                    }
+                    catch {
+                        files.push({ name: fileName, path: filePath, content: undefined, missing: true });
+                    }
+                }
+                else {
+                    files.push({ name: fileName, path: filePath, content: undefined, missing: true });
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    if (cwdFallback) {
+        for (let i = 0; i < files.length; i++) {
+            const f = files[i];
+            if (f.name === 'BOOTSTRAP.md')
+                continue;
+            const template = loadTemplateContent(f.name);
+            if (f.content === template || !f.content) {
+                const cwdPath = path.join(cwdFallback, f.name);
+                try {
+                    const cwdContent = await fsp.readFile(cwdPath, 'utf-8');
+                    if (cwdContent !== template) {
+                        files[i] = { name: f.name, path: cwdPath, content: cwdContent, missing: false };
+                    }
+                }
+                catch {
+                    // cwd version doesn't exist either — keep persona version
+                }
+            }
+        }
+    }
+    return files;
+}
+export async function getPersonaState(personaDir) {
+    return readState(personaDir);
+}
+//# sourceMappingURL=persona-bootstrap.js.map

package/dist/setup/wizard.d.ts

@@ -0,0 +1,32 @@
+import { type AgentConfig } from './config.js';
+export interface SetupResult {
+    config: AgentConfig;
+    apiKey?: string;
+    /** 用户是否选择完成后进入 TUI */
+    enterTui: boolean;
+}
+export declare class SetupWizard {
+    private configManager;
+    constructor();
+    /** 运行完整向导 */
+    run(existingConfig?: AgentConfig): Promise<SetupResult>;
+    /** Step 1: Provider */
+    private stepProvider;
+    /** Step 2: API Key */
+    private stepApiKey;
+    /** Step 3: Model */
+    private stepModel;
+    /** Step 4: maxContext — 自动根据模型推荐，允许修改 */
+    private stepMaxContext;
+    /** Step 5: Confirm */
+    private stepConfirm;
+    /** Step 2.5: llama.cpp setup (local provider) */
+    private stepLlamaCpp;
+    /** 执行 setup-llamacpp.ps1 并实时展示输出 */
+    private runSetupLlamaCpp;
+    /** Step 2.6: 模型文件下载引导 */
+    private stepModelDownload;
+    /** 用户取消时的处理 */
+    private cancel;
+}
+//# sourceMappingURL=wizard.d.ts.map