@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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

@@ -0,0 +1,114 @@
+import type { Config } from './config';
+import type { Definition, Entity, Filter, Rule, Skill, Spec } from './definition';
+export type WorkspaceAssetKind = 'rule' | 'spec' | 'entity' | 'skill' | 'mcpServer' | 'hookPlugin' | 'nativePlugin' | 'agent' | 'command' | 'mode';
+export type WorkspaceAssetAdapter = 'claude-code' | 'codex' | 'opencode';
+export type AssetDiagnosticStatus = 'native' | 'translated' | 'prompt' | 'skipped';
+export interface AssetDiagnostic {
+    assetId: string;
+    adapter: WorkspaceAssetAdapter;
+    status: AssetDiagnosticStatus;
+    reason: string;
+}
+export interface AdapterOverlayEntry {
+    assetId: string;
+    kind: Extract<WorkspaceAssetKind, 'skill' | 'nativePlugin' | 'agent' | 'command' | 'mode'>;
+    sourcePath: string;
+    targetPath: string;
+}
+type WorkspaceAssetOrigin = 'project' | 'plugin' | 'config' | 'fallback';
+type WorkspaceAssetScope = 'workspace' | 'project' | 'user' | 'adapter';
+interface WorkspaceAssetBase<TKind extends WorkspaceAssetKind, TPayload> {
+    id: string;
+    kind: TKind;
+    pluginId?: string;
+    origin: WorkspaceAssetOrigin;
+    scope: WorkspaceAssetScope;
+    enabled: boolean;
+    targets: WorkspaceAssetAdapter[];
+    payload: TPayload;
+}
+interface WorkspaceDocumentPayload<TDefinition> {
+    definition: TDefinition;
+    sourcePath: string;
+}
+interface WorkspaceHookPluginPayload {
+    packageName?: string;
+    config: unknown;
+}
+interface WorkspaceMcpPayload {
+    name: string;
+    config: NonNullable<Config['mcpServers']>[string];
+}
+interface WorkspaceOverlayPayload {
+    sourcePath: string;
+    entryName: string;
+    targetSubpath: string;
+}
+interface WorkspaceConfigNativePluginPayload {
+    name: string;
+    enabled: boolean;
+}
+export type WorkspaceAsset = WorkspaceAssetBase<'rule', WorkspaceDocumentPayload<Definition<Rule>>> | WorkspaceAssetBase<'spec', WorkspaceDocumentPayload<Definition<Spec>>> | WorkspaceAssetBase<'entity', WorkspaceDocumentPayload<Definition<Entity>>> | WorkspaceAssetBase<'skill', WorkspaceDocumentPayload<Definition<Skill>>> | WorkspaceAssetBase<'mcpServer', WorkspaceMcpPayload> | WorkspaceAssetBase<'hookPlugin', WorkspaceHookPluginPayload> | WorkspaceAssetBase<'nativePlugin', WorkspaceConfigNativePluginPayload | WorkspaceOverlayPayload> | WorkspaceAssetBase<'agent', WorkspaceOverlayPayload> | WorkspaceAssetBase<'command', WorkspaceOverlayPayload> | WorkspaceAssetBase<'mode', WorkspaceOverlayPayload>;
+export interface WorkspaceAssetBundle {
+    cwd: string;
+    assets: WorkspaceAsset[];
+    rules: Array<Extract<WorkspaceAsset, {
+        kind: 'rule';
+    }>>;
+    specs: Array<Extract<WorkspaceAsset, {
+        kind: 'spec';
+    }>>;
+    entities: Array<Extract<WorkspaceAsset, {
+        kind: 'entity';
+    }>>;
+    skills: Array<Extract<WorkspaceAsset, {
+        kind: 'skill';
+    }>>;
+    mcpServers: Record<string, Extract<WorkspaceAsset, {
+        kind: 'mcpServer';
+    }>>;
+    hookPlugins: Array<Extract<WorkspaceAsset, {
+        kind: 'hookPlugin';
+    }>>;
+    enabledPlugins: Record<string, boolean>;
+    extraKnownMarketplaces: Config['extraKnownMarketplaces'];
+    defaultIncludeMcpServers: string[];
+    defaultExcludeMcpServers: string[];
+}
+export interface PromptAssetResolution {
+    rules: Definition<Rule>[];
+    targetSkills: Definition<Skill>[];
+    entities: Definition<Entity>[];
+    skills: Definition<Skill>[];
+    specs: Definition<Spec>[];
+    targetBody: string;
+    promptAssetIds: string[];
+}
+export interface WorkspaceSkillSelection {
+    include?: string[];
+    exclude?: string[];
+}
+export interface WorkspaceMcpSelection {
+    include?: string[];
+    exclude?: string[];
+}
+export interface ResolvedPromptAssetOptions {
+    systemPrompt?: string;
+    tools?: Filter;
+    mcpServers?: WorkspaceMcpSelection;
+    promptAssetIds?: string[];
+}
+export interface AdapterAssetPlan {
+    adapter: WorkspaceAssetAdapter;
+    diagnostics: AssetDiagnostic[];
+    mcpServers: Record<string, NonNullable<Config['mcpServers']>[string]>;
+    overlays: AdapterOverlayEntry[];
+    native: {
+        enabledPlugins?: Record<string, boolean>;
+        extraKnownMarketplaces?: Config['extraKnownMarketplaces'];
+        codexHooks?: {
+            supportedEvents: string[];
+        };
+    };
+}
+export {};

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

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

package/dist/packages/utils/__tests__/cache.spec.d.ts

@@ -0,0 +1 @@
+import '../../adapters/codex/src/adapter-config.js';

package/dist/packages/utils/__tests__/cache.spec.js

@@ -0,0 +1,27 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import '../../adapters/codex/src/adapter-config.js';
+import { getCache, getCachePath, setCache } from '#~/cache.js';
+describe('cache utils', () => {
+    const tempDirs = [];
+    afterEach(async () => {
+        await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+    });
+    it('returns undefined when the cache file does not exist', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-cache-'));
+        tempDirs.push(cwd);
+        const result = await getCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads');
+        expect(result).toBeUndefined();
+    });
+    it('writes and reads cache values for a session-scoped key', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-cache-'));
+        tempDirs.push(cwd);
+        const expectedValue = { sessionA: 'thr_123' };
+        const writeResult = await setCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads', expectedValue);
+        const readResult = await getCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads');
+        expect(writeResult.cachePath).toBe(getCachePath(cwd, 'task-1', 'session-1', 'adapter.codex.threads'));
+        expect(readResult).toEqual(expectedValue);
+    });
+});

package/dist/packages/utils/__tests__/chat-message.spec.d.ts

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

package/dist/packages/utils/__tests__/chat-message.spec.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { extractTextFromMessage } from '#~/chat-message.js';
+describe('chat message helpers', () => {
+    it('concatenates text fragments from structured content', () => {
+        expect(extractTextFromMessage({
+            id: 'msg-1',
+            role: 'assistant',
+            createdAt: Date.now(),
+            content: [
+                { type: 'text', text: 'hello ' },
+                { type: 'image', url: 'https://example.com/x.png' },
+                { type: 'text', text: 'world' }
+            ]
+        })).toBe('hello world');
+    });
+    it('returns plain string content directly', () => {
+        expect(extractTextFromMessage({
+            id: 'msg-2',
+            role: 'assistant',
+            createdAt: Date.now(),
+            content: 'plain text'
+        })).toBe('plain text');
+    });
+});

package/dist/packages/utils/__tests__/create-logger.spec.d.ts

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

package/dist/packages/utils/__tests__/create-logger.spec.js

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createLogger } from '#~/create-logger.js';
+async function listFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return listFiles(entryPath);
+        }
+        return [entryPath];
+    }));
+    return files.flat();
+}
+describe('createLogger', () => {
+    const tempDirs = [];
+    afterEach(async () => {
+        vi.useRealTimers();
+        await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+    });
+    it('creates a canonical session log file under the task log directory', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.info('hello');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const files = await listFiles(join(cwd, '.ai/logs/task-1'));
+        expect(files).toEqual([join(cwd, '.ai/logs/task-1/session-1.log.md')]);
+        expect(await readFile(files[0], 'utf8')).toContain('hello');
+    });
+    it('uses info as the default level', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.debug('Claude Code CLI stdout:', { line: 'hidden by default' });
+        logger.info('hello');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__I__ hello');
+        expect(content).not.toContain('Claude Code CLI stdout:');
+        expect(content).not.toContain('__D__');
+    });
+    it('keeps writing resumed logs into the canonical session file even if legacy dated logs exist', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const legacyDir = join(cwd, '.ai/logs/task-1/2026-3-19-22');
+        const legacyPath = join(legacyDir, 'session-1.log.md');
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        await mkdir(legacyDir, { recursive: true });
+        await writeFile(legacyPath, '# legacy log\n');
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.info('follow up');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const files = await listFiles(join(cwd, '.ai/logs/task-1'));
+        expect(files.sort()).toEqual([canonicalPath, legacyPath].sort());
+        expect(await readFile(canonicalPath, 'utf8')).toContain('follow up');
+        expect(await readFile(legacyPath, 'utf8')).toBe('# legacy log\n');
+    });
+    it('skips debug entries when log level is info', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-03-20T10:00:00.000Z'));
+        const logger = createLogger(cwd, 'task-1', 'session-1', '', 'info');
+        logger.debug('Claude Code CLI stdout:', { line: 'debug only' });
+        logger.info('session started');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__I__ session started');
+        expect(content).not.toContain('Claude Code CLI stdout:');
+        expect(content).not.toContain('__D__');
+    });
+    it('keeps debug entries when log level is debug', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1', '', 'debug');
+        logger.debug('Claude Code CLI stdout:', { line: 'debug enabled' });
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__D__ Claude Code CLI stdout:');
+        expect(content).toContain('"line": "debug enabled"');
+    });
+});

package/dist/packages/utils/__tests__/document-path.spec.d.ts

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

package/dist/packages/utils/__tests__/document-path.spec.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { normalizePath, resolveDocumentName, resolvePromptPath, resolveRelativePath, resolveSpecIdentifier } from '#~/document-path.js';
+describe('document path utils', () => {
+    it('normalizes windows separators', () => {
+        expect(normalizePath('foo\\bar\\baz.md')).toBe('foo/bar/baz.md');
+    });
+    it('prefers explicit document names and handles index files', () => {
+        expect(resolveDocumentName('/tmp/specs/index.md', '  explicit  ')).toBe('explicit');
+        expect(resolveDocumentName('/tmp/skills/example/SKILL.md', undefined, ['skill.md'])).toBe('example');
+    });
+    it('resolves relative and prompt paths against the workspace root', () => {
+        expect(resolveRelativePath('/tmp/project', '/tmp/project/.ai/rules/x.md')).toBe('.ai/rules/x.md');
+        expect(resolvePromptPath('/tmp/project', '/outside/path/rule.md')).toBe('/outside/path/rule.md');
+    });
+    it('resolves spec identifiers using index.md conventions', () => {
+        expect(resolveSpecIdentifier('/tmp/specs/my-spec/index.md')).toBe('my-spec');
+    });
+});

package/dist/packages/utils/__tests__/log-level.spec.d.ts

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

package/dist/packages/utils/__tests__/log-level.spec.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { resolveServerLogLevel } from '#~/log-level.js';
+describe('log level helpers', () => {
+    it('forces debug level when __VF_PROJECT_AI_SERVER_DEBUG__ is enabled', () => {
+        expect(resolveServerLogLevel({
+            __VF_PROJECT_AI_SERVER_LOG_LEVEL__: 'error',
+            __VF_PROJECT_AI_SERVER_DEBUG__: 'true'
+        })).toBe('debug');
+    });
+    it('defaults to info when no debug config is provided', () => {
+        expect(resolveServerLogLevel({})).toBe('info');
+    });
+});

package/dist/packages/utils/__tests__/model-selection.spec.d.ts

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

package/dist/packages/utils/__tests__/model-selection.spec.js

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+import { doesModelMatchSelector, evaluateAdapterModelRules, listServiceModels, resolveAdapterConfiguredDefaultModel, resolveAdapterModelCompatibility, resolveDefaultModelSelection, resolveModelDefaultAdapter, resolveModelMetadata, resolveModelSelection } from '#~/model-selection.js';
+const modelServices = {
+    serviceA: {
+        apiBaseUrl: 'https://service-a.example.com',
+        apiKey: 'token-a',
+        models: ['modelX', 'modelAOnly']
+    },
+    serviceB: {
+        apiBaseUrl: 'https://service-b.example.com',
+        apiKey: 'token-b',
+        models: ['modelX', 'modelBOnly']
+    }
+};
+describe('model selection utilities', () => {
+    it('resolves exact selector metadata before service-level metadata', () => {
+        const models = {
+            serviceA: { defaultAdapter: 'claude-code' },
+            'serviceA,modelX': { defaultAdapter: 'codex' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceA,modelX',
+            models
+        })).toBe('codex');
+        expect(resolveModelMetadata({
+            model: 'serviceA,modelAOnly',
+            models
+        })).toEqual({ defaultAdapter: 'claude-code' });
+    });
+    it('ignores invalid selector keys and falls back to service entries', () => {
+        const models = {
+            modelX: { defaultAdapter: 'codex' },
+            serviceB: { defaultAdapter: 'claude-code' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceB,modelX',
+            models
+        })).toBe('claude-code');
+    });
+    it('resolves raw models through the preferred default service', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveModelSelection({
+            value: 'modelX',
+            serviceModels,
+            preferredServiceKey: 'serviceB',
+            preserveUnknown: false
+        })).toBe('serviceB,modelX');
+    });
+    it('falls back to default service first model when no explicit model is configured', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultModelSelection({
+            defaultModelService: 'serviceB',
+            serviceModels,
+            preserveUnknownDefaultModel: false
+        })).toBe('serviceB,modelX');
+    });
+    it('matches service selectors and exact selectors for routed models', () => {
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA,modelX'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceB'
+        })).toBe(false);
+    });
+    it('prefers adapter defaultModel before global defaults', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterConfiguredDefaultModel({
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly'
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknown: false
+        })).toBe('serviceB,modelBOnly');
+    });
+    it('treats service selectors as valid includeModels rules', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+        expect(evaluateAdapterModelRules({
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: false,
+            reason: 'not_included'
+        });
+    });
+    it('does not let includeModels reject the literal default model', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'default',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+    });
+    it('falls back to adapter defaultModel when the selected model is excluded', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly',
+                excludeModels: ['serviceA,modelX']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            model: 'serviceB,modelBOnly',
+            warning: {
+                adapter: 'codex',
+                requestedModel: 'serviceA,modelX',
+                resolvedModel: 'serviceB,modelBOnly',
+                reason: 'excluded'
+            }
+        });
+    });
+    it('returns an error when adapter rules reject the model and no defaultModel exists', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            error: {
+                type: 'missing_default_model',
+                adapter: 'codex',
+                requestedModel: 'serviceB,modelX',
+                reason: 'not_included'
+            }
+        });
+    });
+});

package/dist/packages/utils/__tests__/system.spec.d.ts

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

package/dist/packages/utils/__tests__/system.spec.js

@@ -0,0 +1,29 @@
+import { describe, expect, it, vi } from 'vitest';
+import { notify, notifyOptionsSchema } from '#~/system.js';
+const notifierNotify = vi.hoisted(() => vi.fn());
+vi.mock('node-notifier', () => ({
+    default: {
+        notify: notifierNotify
+    }
+}));
+describe('system helpers', () => {
+    it('exposes the notification schema', () => {
+        expect(notifyOptionsSchema.parse({
+            description: 'task completed'
+        })).toEqual({
+            description: 'task completed'
+        });
+    });
+    it('calls node-notifier and resolves without confirmation by default', async () => {
+        notifierNotify.mockImplementation((_options, callback) => {
+            callback?.(null, 'unused', undefined);
+        });
+        const result = await notify({
+            description: 'task completed',
+            sound: false
+        });
+        expect(notifierNotify).toHaveBeenCalledOnce();
+        expect(result.response).toBe('default');
+        expect(result.metadata?.activationType).toBe('default');
+    });
+});

package/dist/packages/utils/__tests__/uuid.spec.d.ts

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

package/dist/packages/utils/__tests__/uuid.spec.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+import { uuid } from '#~/uuid.js';
+describe('uuid helper', () => {
+    it('creates RFC4122 v4-shaped ids', () => {
+        expect(uuid()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    });
+});

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

@@ -0,0 +1,6 @@
+import type { Cache } from '@vibe-forge/types';
+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/utils/src/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/utils/src/chat-message.d.ts

@@ -0,0 +1,2 @@
+import type { ChatMessage } from '@vibe-forge/types';
+export declare const extractTextFromMessage: (message: ChatMessage) => string;

package/dist/packages/utils/src/chat-message.js

@@ -0,0 +1,12 @@
+export const extractTextFromMessage = (message) => {
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        return message.content
+            .filter((content) => content.type === 'text')
+            .map((content) => ('text' in content ? content.text : ''))
+            .join('');
+    }
+    return '';
+};

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

@@ -0,0 +1,3 @@
+import type { LogLevel, Logger } from '@vibe-forge/types';
+export type { Logger } from '@vibe-forge/types';
+export declare const createLogger: (cwd: string, taskId: string, sessionId: string, logPrefix?: string, level?: LogLevel) => Logger;

package/dist/packages/utils/src/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/utils/src/document-path.d.ts

@@ -0,0 +1,5 @@
+export declare const normalizePath: (value: string) => string;
+export declare const resolveRelativePath: (cwd: string, value: string) => string;
+export declare const resolvePromptPath: (cwd: string, value: string) => string;
+export declare const resolveDocumentName: (path: string, explicitName?: string, indexFileNames?: string[]) => string;
+export declare const resolveSpecIdentifier: (path: string, explicitName?: string) => string;