@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/core/src/hooks/native.js

@@ -0,0 +1,65 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+export const NATIVE_HOOK_BRIDGE_ADAPTER_ENV = '__VF_VIBE_FORGE_HOOK_BRIDGE_ADAPTER__';
+const isPlainObject = (value) => (value != null && typeof value === 'object' && !Array.isArray(value));
+export const hasManagedHookPlugins = (ctx) => (ctx.assets?.hookPlugins.length ?? 0) > 0;
+export const resolveMockHome = (cwd, env) => {
+    const explicitHome = env.HOME?.trim() || process.env.HOME?.trim();
+    return explicitHome ? resolve(explicitHome) : resolve(cwd, '.ai', '.mock');
+};
+export const resolveManagedHookPackageDir = () => {
+    try {
+        const pkgJsonPath = require.resolve('@vibe-forge/core/package.json');
+        return dirname(pkgJsonPath);
+    }
+    catch (error) {
+        throw new Error('Failed to resolve @vibe-forge/core managed hook entry', { cause: error });
+    }
+};
+export const resolveManagedHookScriptPath = (fileName) => (resolve(resolveManagedHookPackageDir(), fileName));
+export const shellQuote = (value) => JSON.stringify(value);
+export const buildNodeScriptCommand = (params) => `${shellQuote(params.nodePath)} ${shellQuote(params.scriptPath)}`;
+export const prepareManagedHookRuntime = (ctx) => {
+    const mockHome = resolveMockHome(ctx.cwd, ctx.env);
+    const nodePath = process.execPath;
+    ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ = ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? ctx.cwd;
+    ctx.env.__VF_PROJECT_NODE_PATH__ = nodePath;
+    return {
+        mockHome,
+        nodePath
+    };
+};
+export const readJsonFileOrDefault = async (filePath, fallback) => {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return fallback;
+        throw error;
+    }
+};
+export const writeJsonFile = async (filePath, value) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+};
+export const mergeManagedHookGroups = (params) => {
+    const parsed = isPlainObject(params.existing) ? params.existing : {};
+    const hooks = isPlainObject(parsed.hooks)
+        ? parsed.hooks
+        : {};
+    const nextHooks = { ...hooks };
+    for (const eventName of params.eventNames) {
+        const groups = Array.isArray(hooks[eventName])
+            ? hooks[eventName].filter(group => !params.isManagedGroup(group))
+            : [];
+        nextHooks[eventName] = params.enabled && (params.shouldManageEvent?.(eventName) ?? true)
+            ? [...groups, params.createGroup(eventName)]
+            : groups;
+    }
+    return {
+        ...parsed,
+        hooks: nextHooks
+    };
+};

package/dist/packages/core/src/hooks/runtime.d.ts

@@ -0,0 +1,27 @@
+import type { HookContext, Plugin } from './index';
+import type { HookInput, HookInputs, HookOutputCore, HookOutputs } from './type';
+export declare const callPluginHook: <K extends keyof HookInputs>(eventName: K, context: HookContext, input: HookInputs[K], plugins?: Partial<Plugin>[]) => Promise<HookOutputs[K]>;
+export declare const executeHookInput: (input: HookInput, env?: Record<string, string | null | undefined>) => Promise<HookOutputCore | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "PreToolUse";
+        permissionDecision: "allow" | "deny" | "ask";
+        permissionDecisionReason: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "PostToolUse";
+        additionalContext: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "UserPromptSubmit";
+        additionalContext: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "SessionStart";
+        additionalContext: string;
+    };
+})>;
+export declare const readHookInput: () => Promise<HookInput>;
+export declare const runHookCli: () => Promise<void>;

package/dist/packages/core/src/hooks/runtime.js

@@ -0,0 +1,87 @@
+import { Buffer } from 'node:buffer';
+import process from 'node:process';
+import { loadConfig, resetConfigCache } from '#~/config/load.js';
+import { resolveServerLogLevel } from '#~/env.js';
+import { createLogger } from '#~/utils/create-logger.js';
+import { transformCamelKey } from '#~/utils/string-transform.js';
+import { resolvePlugins } from './loader';
+export const callPluginHook = async (eventName, context, input, plugins = []) => {
+    const { logger } = context;
+    const filteredPlugins = plugins.filter((item) => !!item && !!item[eventName]);
+    let index = 0;
+    const next = async () => {
+        if (index >= filteredPlugins.length) {
+            return { continue: true };
+        }
+        const currentPlugin = filteredPlugins[index];
+        const name = currentPlugin.name ?? '<anonymous>';
+        const hook = currentPlugin[eventName];
+        index++;
+        const withNameLogger = {
+            ...logger,
+            info: logger.info.bind(logger, `[plugin.${name}]`),
+            warn: logger.warn.bind(logger, `[plugin.${name}]`),
+            debug: logger.debug.bind(logger, `[plugin.${name}]`),
+            error: logger.error.bind(logger, `[plugin.${name}]`)
+        };
+        try {
+            return await hook({
+                ...context,
+                logger: withNameLogger
+            }, input, next);
+        }
+        catch (error) {
+            if (error instanceof Error && !error.name.includes('[plugin.')) {
+                error.name = `${error.name}[plugin.${name}]`;
+            }
+            throw error;
+        }
+    };
+    return next();
+};
+export const executeHookInput = async (input, env = process.env) => {
+    const workspaceFolder = env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? input.cwd ?? process.env.HOME ?? '/';
+    const ctxId = env.__VF_PROJECT_AI_CTX_ID__ ?? input.sessionId ?? 'default';
+    const logPrefix = env.__VF_PROJECT_AI_LOG_PREFIX__ ?? '';
+    const loggerBase = createLogger(workspaceFolder, ctxId, input.sessionId, logPrefix, resolveServerLogLevel(env));
+    const logger = {
+        ...loggerBase,
+        info: (...args) => loggerBase.info(`[${input.hookEventName}]`, ...args),
+        warn: (...args) => loggerBase.warn(`[${input.hookEventName}]`, ...args),
+        debug: (...args) => loggerBase.debug(`[${input.hookEventName}]`, ...args),
+        error: (...args) => loggerBase.error(`[${input.hookEventName}]`, ...args)
+    };
+    resetConfigCache();
+    const jsonVariables = {
+        ...env,
+        WORKSPACE_FOLDER: workspaceFolder,
+        __VF_PROJECT_WORKSPACE_FOLDER__: workspaceFolder
+    };
+    const [config, userConfig] = await loadConfig({ jsonVariables });
+    const plugins = [
+        ...await resolvePlugins(config?.plugins ?? [], config?.enabledPlugins ?? {}),
+        ...await resolvePlugins(userConfig?.plugins ?? [], userConfig?.enabledPlugins ?? {})
+    ];
+    return callPluginHook(input.hookEventName, { logger }, input, plugins);
+};
+export const readHookInput = async () => {
+    const stdoutBuffer = await new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on('data', chunk => chunks.push(chunk));
+        process.stdin.once('end', () => resolve(Buffer.concat(chunks)));
+    });
+    return transformCamelKey(JSON.parse(stdoutBuffer.toString() || '{}'));
+};
+export const runHookCli = async () => {
+    try {
+        const input = await readHookInput();
+        const result = await executeHookInput(input);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            continue: false,
+            stopReason: `run hook error: ${String(error)}`
+        })}\n`);
+    }
+};

package/dist/packages/core/src/hooks/type.d.ts

@@ -0,0 +1,148 @@
+import type { AdapterQueryOptions } from '../adapter';
+export type HookSource = 'native' | 'bridge';
+export interface HookToolCall {
+    toolCallId?: string;
+    toolName: string;
+    toolInput?: unknown;
+}
+export interface HookToolResult extends HookToolCall {
+    toolResponse?: unknown;
+    isError?: boolean;
+}
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
+ */
+export interface HookInputCore {
+    cwd: string;
+    sessionId: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    adapter?: string;
+    runtime?: AdapterQueryOptions['runtime'];
+    hookSource?: HookSource;
+    canBlock?: boolean;
+}
+export interface HookInputs {
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-input
+     */
+    PreToolUse: HookInputCore & HookToolCall;
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-input
+     */
+    PostToolUse: HookInputCore & HookToolResult;
+    Notification: HookInputCore;
+    UserPromptSubmit: HookInputCore & {
+        prompt: string;
+    };
+    Stop: HookInputCore & {
+        stopHookActive?: boolean;
+        lastAssistantMessage?: string;
+    };
+    SubagentStop: HookInputCore;
+    PreCompact: HookInputCore;
+    SessionStart: HookInputCore & {
+        source?: 'startup' | 'resume';
+        model?: string;
+    };
+    SessionEnd: HookInputCore & {
+        reason: string;
+        exitCode?: number;
+        stderr?: string;
+        lastAssistantMessage?: string;
+    };
+    StartTasks: HookInputCore & {
+        tasks: Array<{
+            description: string;
+            type: 'default' | 'spec' | 'entity';
+            name?: string;
+            adapter?: string;
+            background?: boolean;
+        }>;
+    };
+    GenerateSystemPrompt: HookInputCore & {
+        type?: 'spec' | 'entity';
+        name?: string;
+        data?: unknown;
+    };
+    TaskStart: HookInputCore & {
+        adapter?: string;
+        options: unknown;
+        adapterOptions: unknown;
+    };
+    TaskStop: HookInputCore & {
+        exitCode?: number;
+        stderr?: string;
+        adapter?: string;
+        options: unknown;
+        adapterOptions: unknown;
+    };
+}
+export type HookInput = HookInputs[keyof HookInputs];
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/hooks#common-json-fields
+ */
+export interface HookOutputCore {
+    /**
+     * Whether Claude should continue after hook execution
+     * @default true
+     */
+    continue?: boolean;
+    /**
+     * Message shown when continue is false
+     */
+    stopReason?: string;
+    /**
+     * Hide stdout from transcript mode
+     * @default false
+     */
+    suppressOutput?: boolean;
+    /**
+     * Optional warning message shown to the user
+     */
+    systemMessage?: string;
+}
+export interface HookOutputs {
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-decision-control
+     */
+    PreToolUse: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'PreToolUse';
+            permissionDecision: 'allow' | 'deny' | 'ask';
+            permissionDecisionReason: string;
+        };
+    };
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-decision-control
+     */
+    PostToolUse: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'PostToolUse';
+            additionalContext: string;
+        };
+    };
+    Notification: HookOutputCore;
+    Stop: HookOutputCore;
+    SessionStart: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'SessionStart';
+            additionalContext: string;
+        };
+    };
+    SessionEnd: HookOutputCore;
+    SubagentStop: HookOutputCore;
+    PreCompact: HookOutputCore;
+    UserPromptSubmit: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'UserPromptSubmit';
+            additionalContext: string;
+        };
+    };
+    StartTasks: HookOutputCore;
+    GenerateSystemPrompt: HookOutputCore;
+    TaskStart: HookOutputCore;
+    TaskStop: HookOutputCore;
+}
+export type HookOutput = HookOutputs[keyof HookOutputs];

package/dist/packages/core/src/hooks/type.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/core/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './env';
+export * from './schema';
+export * from './tools';
+export * from './types';
+export * from './ws';

package/dist/packages/core/src/index.js

@@ -0,0 +1,5 @@
+export * from './env';
+export * from './schema';
+export * from './tools';
+export * from './types';
+export * from './ws';

package/dist/packages/core/src/schema.d.ts

@@ -0,0 +1,42 @@
+import z from 'zod';
+export declare const InteractionOptionSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    description?: string | undefined;
+}, {
+    label: string;
+    description?: string | undefined;
+}>;
+export declare const AskUserQuestionParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    question: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        description?: string | undefined;
+    }>, "many">>;
+    multiselect: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    question: string;
+    options?: {
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    multiselect?: boolean | undefined;
+}, {
+    sessionId: string;
+    question: string;
+    options?: {
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    multiselect?: boolean | undefined;
+}>;

package/dist/packages/core/src/schema.js

@@ -0,0 +1,11 @@
+import z from 'zod';
+export const InteractionOptionSchema = z.object({
+    label: z.string(),
+    description: z.string().optional()
+});
+export const AskUserQuestionParamsSchema = z.object({
+    sessionId: z.string(),
+    question: z.string(),
+    options: z.array(InteractionOptionSchema).optional(),
+    multiselect: z.boolean().optional()
+});

package/dist/packages/core/src/tools.d.ts

@@ -0,0 +1,36 @@
+export interface StopTaskToolInput {
+    task_id?: string;
+}
+export interface StartTasksToolInput {
+    tasks: Array<{
+        description?: string;
+        type?: 'default' | 'spec' | 'entity';
+        name?: string;
+        adapter?: string;
+        permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions';
+        background?: boolean;
+    }>;
+}
+export interface GetTaskInfoToolInput {
+    taskId: string;
+}
+export interface ListTasksToolInput {
+}
+export interface ToolInputs {
+    StartTasks: StartTasksToolInput;
+    GetTaskInfo: GetTaskInfoToolInput;
+    ListTasks: ListTasksToolInput;
+    StopTask: StopTaskToolInput;
+}
+export interface ToolOutputs {
+}
+export type ToolName = keyof ToolInputs;
+export type ToolInput = keyof ToolInputs extends infer Keys ? Keys extends infer Key extends keyof ToolInputs ? {
+    toolName: Key;
+    toolInput: ToolInputs[Key];
+} : never : never;
+export type ToolOutput = keyof ToolOutputs extends infer Keys ? Keys extends infer Key extends keyof ToolOutputs ? {
+    toolName: Key;
+    toolInput: ToolInputs[Key];
+    toolResponse?: ToolOutputs[Key];
+} : never : never;

package/dist/packages/core/src/tools.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/core/src/types.d.ts

@@ -0,0 +1 @@
+export type { AskUserQuestionParams, ChatMessage, ChatMessageContent, ConfigSource, Project, Session, SessionPermissionMode, SessionStatus, TaskDetail, TaskRuntime } from '@vibe-forge/types';

package/dist/packages/core/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/core/src/utils/cache.d.ts

@@ -0,0 +1,10 @@
+import type { Cache } from '@vibe-forge/core';
+declare module '@vibe-forge/core' {
+    interface Cache {
+    }
+}
+export declare const getCachePath: (cwd: string, taskId: string, sessionId: string | undefined, key: keyof Cache) => string;
+export declare const setCache: <K extends keyof Cache>(cwd: string, taskId: string, sessionId: string | undefined, key: K, value: Cache[K]) => Promise<{
+    cachePath: string;
+}>;
+export declare const getCache: <K extends keyof Cache>(cwd: string, taskId: string, sessionId: string | undefined, key: K) => Promise<Cache[K] | undefined>;

package/dist/packages/core/src/utils/cache.js

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+export const getCachePath = (cwd, taskId, sessionId, key) => {
+    const taskDir = resolve(cwd, '.ai/caches', taskId);
+    const cacheDir = sessionId ? resolve(taskDir, sessionId) : taskDir;
+    return resolve(cacheDir, `${key}.json`);
+};
+export const setCache = async (cwd, taskId, sessionId, key, value) => {
+    const cachePath = getCachePath(cwd, taskId, sessionId, key);
+    const cacheDir = dirname(cachePath);
+    try {
+        await fs.access(cacheDir);
+    }
+    catch {
+        await fs.mkdir(cacheDir, { recursive: true });
+    }
+    await fs.writeFile(cachePath, JSON.stringify(value, null, 2), {
+        flag: 'w'
+    });
+    return { cachePath };
+};
+export const getCache = async (cwd, taskId, sessionId, key) => {
+    const cachePath = getCachePath(cwd, taskId, sessionId, key);
+    try {
+        await fs.access(cachePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+    return JSON.parse(await fs.readFile(cachePath, 'utf-8'));
+};

package/dist/packages/core/src/utils/create-logger.d.ts

@@ -0,0 +1,15 @@
+import type { LogLevel } from '#~/env.js';
+export interface Logger {
+    stream: NodeJS.WritableStream;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export declare const createLogger: (cwd: string, taskId: string, sessionId: string, logPrefix?: string, level?: LogLevel) => {
+    stream: import("fs").WriteStream;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};

package/dist/packages/core/src/utils/create-logger.js

@@ -0,0 +1,58 @@
+import { createWriteStream, existsSync, mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+const LOG_LEVEL_PRIORITY = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40
+};
+export const createLogger = (cwd, taskId, sessionId, logPrefix = '', level = 'info') => {
+    const normalizedSessionId = sessionId ?? 'default';
+    const taskDir = resolve(cwd, `.ai${logPrefix}/logs/${taskId}`);
+    const loggerFilePath = resolve(taskDir, `${normalizedSessionId}.log.md`);
+    // 默认日志文件不存在时，创建一个默认的日志文件
+    if (!existsSync(loggerFilePath)) {
+        mkdirSync(dirname(loggerFilePath), { recursive: true });
+    }
+    const loggerStream = createWriteStream(loggerFilePath, {
+        flags: 'a'
+    });
+    const createLog = (tag, currentLevel) => (...args) => {
+        if (LOG_LEVEL_PRIORITY[currentLevel] < LOG_LEVEL_PRIORITY[level]) {
+            return;
+        }
+        const msg = args
+            .map((arg) => {
+            if (typeof arg === 'string') {
+                return arg;
+            }
+            if (arg instanceof Error) {
+                return ('\n```text\n' +
+                    `${arg.stack}\n` +
+                    '```');
+            }
+            return ('\n```json\n' +
+                `${JSON.stringify(arg, null, 2)}\n` +
+                '```');
+        })
+            .join(' ');
+        const now = new Date().toLocaleString();
+        if (loggerStream.writableEnded) {
+            const tempLoggerStream = createWriteStream(loggerFilePath, {
+                flags: 'a'
+            });
+            tempLoggerStream.write(`# [${now}] __E__ UNEXPECTED LOGGER STREAM ENDED\n`);
+            tempLoggerStream.write(`# [${now}] __${tag}__ ${msg}\n`);
+            tempLoggerStream.end();
+            return;
+        }
+        loggerStream.write(`# [${now}] __${tag}__ ${msg}\n`);
+    };
+    return {
+        stream: loggerStream,
+        info: createLog('I', 'info'),
+        warn: createLog('W', 'warn'),
+        debug: createLog('D', 'debug'),
+        error: createLog('E', 'error')
+    };
+};

package/dist/packages/core/src/utils/definition-loader.d.ts

@@ -0,0 +1,89 @@
+export interface Filter {
+    include?: string[];
+    exclude?: string[];
+}
+export interface Rule {
+    name?: string;
+    description?: string;
+    globs?: string | string[];
+    /**
+     * 是否默认加载至系统上下文
+     */
+    always?: boolean;
+}
+export interface Spec {
+    name?: string;
+    always?: boolean;
+    description?: string;
+    tags?: string[];
+    params?: {
+        name: string;
+        description?: string;
+    }[];
+    rules?: string[];
+    skills?: string[];
+    mcpServers?: Filter;
+    tools?: Filter;
+}
+export interface LocalRuleReference {
+    type?: 'local';
+    path: string;
+    desc?: string;
+}
+export interface RemoteRuleReference {
+    type: 'remote';
+    tags?: string[];
+    desc?: string;
+}
+export type RuleReference = string | LocalRuleReference | RemoteRuleReference;
+export interface SkillSelection {
+    type: 'include' | 'exclude';
+    list: string[];
+}
+export interface Entity {
+    name?: string;
+    always?: boolean;
+    description?: string;
+    tags?: string[];
+    prompt?: string;
+    promptPath?: string;
+    rules?: RuleReference[];
+    skills?: string[] | SkillSelection;
+    mcpServers?: Filter;
+    tools?: Filter;
+}
+export interface Skill {
+    name?: string;
+    description?: string;
+    always?: boolean;
+}
+export interface Definition<T> {
+    path: string;
+    body: string;
+    attributes: T;
+}
+/**
+ * 以结构化的方式加载本地文档数据
+ */
+export declare const loadLocalDocuments: <Attrs extends object>(paths: string[]) => Promise<Definition<Attrs>[]>;
+export declare class DefinitionLoader {
+    private readonly cwd;
+    constructor(cwd?: string);
+    private scan;
+    loadRules(rules: RuleReference[], options?: {
+        baseDir?: string;
+    }): Promise<Definition<Rule>[]>;
+    loadDefaultRules(): Promise<Definition<Rule>[]>;
+    generateRulesPrompt(rules: Definition<Rule>[]): string;
+    loadSkills(skills?: string[]): Promise<Definition<Skill>[]>;
+    loadDefaultSkills(): Promise<Definition<Skill>[]>;
+    generateSkillsPrompt(skills: Definition<Skill>[]): string;
+    generateSkillsRoutePrompt(skills: Definition<Skill>[]): string;
+    loadSpec(name: string): Promise<Definition<Spec> | undefined>;
+    loadDefaultSpecs(): Promise<Definition<Spec>[]>;
+    generateSpecRoutePrompt(specsDocuments: Definition<Spec>[]): string;
+    loadEntity(name: string): Promise<Definition<Entity> | undefined>;
+    private loadEntityFromJson;
+    loadDefaultEntities(): Promise<Definition<Entity>[]>;
+    generateEntitiesRoutePrompt(entities: Definition<Entity>[]): string;
+}