@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/workspace-assets/src/helpers.js

@@ -0,0 +1,23 @@
+import { resolveRelativePath } from '@vibe-forge/utils';
+export const resolvePluginIdFromPath = (cwd, path) => {
+    const relativePath = resolveRelativePath(cwd, path);
+    const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\//);
+    return match?.[1];
+};
+export const isPluginEnabled = (enabledPlugins, pluginId) => pluginId == null || enabledPlugins[pluginId] !== false;
+export const mergeRecord = (left, right) => ({
+    ...(left ?? {}),
+    ...(right ?? {})
+});
+export const uniqueValues = (values) => Array.from(new Set(values.filter(Boolean)));
+export const assetOriginPriority = {
+    project: 0,
+    plugin: 1,
+    config: 2,
+    fallback: 3
+};
+export const toAssetScope = (origin) => (origin === 'config'
+    ? 'project'
+    : origin === 'fallback'
+        ? 'adapter'
+        : 'workspace');

package/dist/packages/workspace-assets/src/index.d.ts

@@ -0,0 +1,3 @@
+export { buildAdapterAssetPlan } from './adapter-asset-plan';
+export { resolveWorkspaceAssetBundle } from './bundle';
+export { resolvePromptAssetSelection } from './prompt-selection';

package/dist/packages/workspace-assets/src/index.js

@@ -0,0 +1,3 @@
+export { buildAdapterAssetPlan } from './adapter-asset-plan';
+export { resolveWorkspaceAssetBundle } from './bundle';
+export { resolvePromptAssetSelection } from './prompt-selection';

package/dist/packages/workspace-assets/src/internal-types.d.ts

@@ -0,0 +1,26 @@
+import type { WorkspaceAsset } from '@vibe-forge/types';
+export interface WorkspaceDocumentPayload<TDefinition> {
+    definition: TDefinition;
+    sourcePath: string;
+}
+export interface WorkspaceOverlayPayload {
+    sourcePath: string;
+    entryName: string;
+    targetSubpath: string;
+}
+export type WorkspaceOpenCodeOverlayAsset = (Extract<WorkspaceAsset, {
+    kind: 'nativePlugin';
+}> & {
+    payload: WorkspaceOverlayPayload;
+}) | Extract<WorkspaceAsset, {
+    kind: 'agent' | 'command' | 'mode';
+}>;
+export type WorkspaceDocumentAsset<TDefinition> = Extract<WorkspaceAsset, {
+    kind: 'rule' | 'spec' | 'entity' | 'skill';
+}> & {
+    payload: WorkspaceDocumentPayload<TDefinition & {
+        path: string;
+    }>;
+};
+export declare const isOverlayPayload: (payload: unknown) => payload is WorkspaceOverlayPayload;
+export declare const isOpenCodeOverlayAsset: (asset: WorkspaceAsset) => asset is WorkspaceOpenCodeOverlayAsset;

package/dist/packages/workspace-assets/src/internal-types.js

@@ -0,0 +1,7 @@
+export const isOverlayPayload = (payload) => (payload != null &&
+    typeof payload === 'object' &&
+    typeof payload.sourcePath === 'string' &&
+    typeof payload.entryName === 'string' &&
+    typeof payload.targetSubpath === 'string');
+export const isOpenCodeOverlayAsset = (asset) => ((asset.kind === 'nativePlugin' || asset.kind === 'agent' || asset.kind === 'command' || asset.kind === 'mode') &&
+    isOverlayPayload(asset.payload));

package/dist/packages/workspace-assets/src/plugin-assets.d.ts

@@ -0,0 +1,12 @@
+import type { Config, WorkspaceAsset } from '@vibe-forge/types';
+import type { WorkspaceOpenCodeOverlayAsset } from './internal-types';
+export declare const loadPluginMcpAssets: (cwd: string, enabledPlugins: Record<string, boolean>) => Promise<Array<Extract<WorkspaceAsset, {
+    kind: "mcpServer";
+}>>>;
+export declare const loadOpenCodeOverlayAssets: (cwd: string, enabledPlugins: Record<string, boolean>) => Promise<WorkspaceOpenCodeOverlayAsset[]>;
+export declare const createHookPluginAssets: (config: Config["plugins"], enabledPlugins: Record<string, boolean>, scope: Extract<WorkspaceAsset["scope"], "project" | "user">) => Array<Extract<WorkspaceAsset, {
+    kind: "hookPlugin";
+}>>;
+export declare const createClaudeNativePluginAssets: (enabledPlugins: Record<string, boolean>) => Array<Extract<WorkspaceAsset, {
+    kind: "nativePlugin";
+}>>;

package/dist/packages/workspace-assets/src/plugin-assets.js

@@ -0,0 +1,146 @@
+import { readFile } from 'node:fs/promises';
+import { basename, extname } from 'node:path';
+import { glob } from 'fast-glob';
+import { resolveRelativePath } from '@vibe-forge/utils';
+import yaml from 'js-yaml';
+import { isPluginEnabled, resolvePluginIdFromPath } from './helpers';
+const parseStructuredDocument = async (path) => {
+    const raw = await readFile(path, 'utf8');
+    const extension = extname(path).toLowerCase();
+    if (extension === '.yaml' || extension === '.yml') {
+        return yaml.load(raw);
+    }
+    return JSON.parse(raw);
+};
+export const loadPluginMcpAssets = async (cwd, enabledPlugins) => {
+    const paths = await glob([
+        '.ai/plugins/*/mcp/*.json',
+        '.ai/plugins/*/mcp/*.yaml',
+        '.ai/plugins/*/mcp/*.yml'
+    ], {
+        cwd,
+        absolute: true
+    });
+    const entries = await Promise.all(paths.map(async (path) => {
+        const pluginId = resolvePluginIdFromPath(cwd, path);
+        if (!isPluginEnabled(enabledPlugins, pluginId))
+            return undefined;
+        const parsed = await parseStructuredDocument(path);
+        if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed))
+            return undefined;
+        const record = parsed;
+        const name = typeof record.name === 'string' && record.name.trim() !== ''
+            ? record.name.trim()
+            : basename(path, extname(path));
+        const { name: _name, ...config } = record;
+        return {
+            id: `mcpServer:${resolveRelativePath(cwd, path)}`,
+            kind: 'mcpServer',
+            pluginId,
+            origin: 'plugin',
+            scope: 'workspace',
+            enabled: true,
+            targets: ['claude-code', 'codex', 'opencode'],
+            payload: {
+                name,
+                config: config
+            }
+        };
+    }));
+    return entries.filter((entry) => entry != null);
+};
+export const loadOpenCodeOverlayAssets = async (cwd, enabledPlugins) => {
+    const paths = await glob([
+        '.ai/plugins/*/opencode/plugins/*',
+        '.ai/plugins/*/opencode/agents/*',
+        '.ai/plugins/*/opencode/commands/*',
+        '.ai/plugins/*/opencode/modes/*'
+    ], {
+        cwd,
+        absolute: true,
+        onlyFiles: false
+    });
+    return paths
+        .map((path) => {
+        const relativePath = resolveRelativePath(cwd, path);
+        const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\/opencode\/(plugins|agents|commands|modes)\/([^/]+)$/);
+        if (!match)
+            return undefined;
+        const [, pluginId, rawFolder, entryName] = match;
+        if (!isPluginEnabled(enabledPlugins, pluginId))
+            return undefined;
+        const base = {
+            pluginId,
+            origin: 'plugin',
+            scope: 'workspace',
+            enabled: true,
+            targets: ['opencode'],
+            payload: {
+                sourcePath: path,
+                entryName,
+                targetSubpath: `${rawFolder}/${entryName}`
+            }
+        };
+        if (rawFolder === 'plugins') {
+            return {
+                id: `nativePlugin:${relativePath}`,
+                kind: 'nativePlugin',
+                ...base
+            };
+        }
+        if (rawFolder === 'agents') {
+            return {
+                id: `agent:${relativePath}`,
+                kind: 'agent',
+                ...base
+            };
+        }
+        if (rawFolder === 'commands') {
+            return {
+                id: `command:${relativePath}`,
+                kind: 'command',
+                ...base
+            };
+        }
+        return {
+            id: `mode:${relativePath}`,
+            kind: 'mode',
+            ...base
+        };
+    })
+        .filter((entry) => entry != null);
+};
+export const createHookPluginAssets = (config, enabledPlugins, scope) => {
+    if (config == null || Array.isArray(config))
+        return [];
+    return Object.entries(config)
+        .filter((entry) => enabledPlugins[entry[0]] !== false)
+        .map(([pluginId, pluginConfig]) => ({
+        id: `hookPlugin:${scope}:${pluginId}`,
+        kind: 'hookPlugin',
+        pluginId,
+        origin: 'config',
+        scope,
+        enabled: true,
+        targets: ['claude-code', 'codex', 'opencode'],
+        payload: {
+            packageName: pluginId,
+            config: pluginConfig
+        }
+    }));
+};
+export const createClaudeNativePluginAssets = (enabledPlugins) => {
+    return Object.entries(enabledPlugins).map(([pluginId, enabled]) => ({
+        id: `nativePlugin:claude-code:${pluginId}`,
+        kind: 'nativePlugin',
+        pluginId,
+        origin: 'config',
+        scope: 'project',
+        enabled,
+        targets: ['claude-code'],
+        payload: {
+            name: pluginId,
+            enabled
+        }
+    }));
+};

package/dist/packages/workspace-assets/src/prompt-selection.d.ts

@@ -0,0 +1,9 @@
+import type { PromptAssetResolution, ResolvedPromptAssetOptions, WorkspaceAssetBundle, WorkspaceSkillSelection } from '@vibe-forge/types';
+export declare function resolvePromptAssetSelection(params: {
+    bundle: WorkspaceAssetBundle;
+    type: 'spec' | 'entity' | undefined;
+    name?: string;
+    input?: {
+        skills?: WorkspaceSkillSelection;
+    };
+}): Promise<[PromptAssetResolution, ResolvedPromptAssetOptions]>;

package/dist/packages/workspace-assets/src/prompt-selection.js

@@ -0,0 +1,97 @@
+import { basename, dirname } from 'node:path';
+import { DefinitionLoader } from '@vibe-forge/definition-loader';
+import { dedupeSkillAssets, filterSkillAssets, pickEntityAsset, pickSpecAsset, resolveExcludedSkillNames, resolveIncludedSkillNames, resolveRulePatterns, resolveSelectedRuleAssets, toDocumentDefinitions, toPromptAssetIds } from './document-assets';
+export async function resolvePromptAssetSelection(params) {
+    const loader = new DefinitionLoader(params.bundle.cwd);
+    const options = {};
+    const systemPromptParts = [];
+    const entities = params.type !== 'entity'
+        ? toDocumentDefinitions(params.bundle.entities)
+        : [];
+    const skills = toDocumentDefinitions(filterSkillAssets(params.bundle.skills, params.input?.skills));
+    const rules = toDocumentDefinitions(params.bundle.rules);
+    const specs = toDocumentDefinitions(params.bundle.specs);
+    const promptAssetIds = new Set([
+        ...toPromptAssetIds(params.bundle.rules),
+        ...(params.type !== 'entity' ? toPromptAssetIds(params.bundle.entities) : []),
+        ...toPromptAssetIds(params.bundle.specs),
+        ...toPromptAssetIds(filterSkillAssets(params.bundle.skills, params.input?.skills))
+    ]);
+    const targetSkillsAssets = [];
+    let targetBody = '';
+    let targetToolsFilter;
+    let targetMcpServersFilter;
+    let selectedSkillAssets = [];
+    if (params.input?.skills?.include != null && params.input.skills.include.length > 0) {
+        selectedSkillAssets = dedupeSkillAssets(filterSkillAssets(params.bundle.skills, { include: params.input.skills.include }));
+    }
+    if (params.type && params.name) {
+        const targetAsset = params.type === 'spec'
+            ? pickSpecAsset(params.bundle, params.name)
+            : pickEntityAsset(params.bundle, params.name);
+        if (targetAsset == null) {
+            throw new Error(`Failed to load ${params.type} ${params.name}`);
+        }
+        const { definition } = targetAsset.payload;
+        const { attributes, body } = definition;
+        promptAssetIds.add(targetAsset.id);
+        if (attributes.rules) {
+            const matchedRuleAssets = await resolveSelectedRuleAssets(params.bundle, resolveRulePatterns(attributes.rules));
+            rules.push(...matchedRuleAssets.map((asset) => ({
+                ...asset.payload.definition,
+                attributes: {
+                    ...asset.payload.definition.attributes,
+                    always: true
+                }
+            })));
+            for (const asset of matchedRuleAssets) {
+                promptAssetIds.add(asset.id);
+            }
+        }
+        if (attributes.skills) {
+            const includedSkillNames = new Set(resolveIncludedSkillNames(attributes.skills));
+            const excludedSkillNames = new Set(resolveExcludedSkillNames(attributes.skills));
+            for (const skillAsset of params.bundle.skills) {
+                const skillName = basename(dirname(skillAsset.payload.definition.path));
+                if (includedSkillNames.size > 0 && !includedSkillNames.has(skillName))
+                    continue;
+                if (excludedSkillNames.has(skillName))
+                    continue;
+                targetSkillsAssets.push(skillAsset);
+                promptAssetIds.add(skillAsset.id);
+            }
+        }
+        targetBody = body;
+        targetToolsFilter = attributes.tools;
+        targetMcpServersFilter = attributes.mcpServers;
+    }
+    const targetSkills = toDocumentDefinitions(targetSkillsAssets);
+    const selectedSkillsPrompt = toDocumentDefinitions(selectedSkillAssets.filter(skill => !targetSkillsAssets.some(target => target.payload.definition.path === skill.payload.definition.path)));
+    systemPromptParts.push(loader.generateRulesPrompt(rules));
+    systemPromptParts.push(loader.generateSkillsPrompt(targetSkills));
+    systemPromptParts.push(loader.generateSkillsPrompt(selectedSkillsPrompt));
+    systemPromptParts.push(loader.generateEntitiesRoutePrompt(entities));
+    systemPromptParts.push(loader.generateSkillsRoutePrompt(skills));
+    systemPromptParts.push(loader.generateSpecRoutePrompt(specs));
+    systemPromptParts.push(targetBody);
+    if (targetToolsFilter) {
+        options.tools = targetToolsFilter;
+    }
+    if (targetMcpServersFilter) {
+        options.mcpServers = targetMcpServersFilter;
+    }
+    options.systemPrompt = systemPromptParts.join('\n\n');
+    options.promptAssetIds = Array.from(promptAssetIds);
+    return [
+        {
+            rules,
+            targetSkills,
+            entities,
+            skills,
+            specs,
+            targetBody,
+            promptAssetIds: Array.from(promptAssetIds)
+        },
+        options
+    ];
+}

package/dist/scripts/__tests__/adapter-e2e/adapter-e2e.spec.d.ts

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

package/dist/scripts/__tests__/adapter-e2e/adapter-e2e.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const harness_1 = require("../../adapter-e2e/harness");
+const assertions_1 = require("./assertions");
+const cases_1 = require("./cases");
+const shouldRunE2E = process.env.VF_RUN_ADAPTER_E2E === '1';
+const describeE2E = shouldRunE2E ? vitest_1.describe.sequential : vitest_1.describe.skip;
+const selectedCases = (0, cases_1.resolveSelectedAdapterE2ECases)(process.env.VF_ADAPTER_E2E_SELECTION ?? 'all', cases_1.ADAPTER_E2E_CASES);
+describeE2E('adapter e2e harness', () => {
+    let harness;
+    (0, vitest_1.beforeAll)(async () => {
+        harness = await (0, harness_1.createAdapterE2EHarness)({
+            cases: selectedCases,
+            passthroughStdIO: process.env.VF_E2E_VERBOSE === '1',
+            printSummary: false
+        });
+    }, 300_000);
+    (0, vitest_1.afterAll)(async () => {
+        await harness?.close();
+    }, 120_000);
+    for (const testCase of selectedCases) {
+        (0, vitest_1.it)(`${testCase.id} completes a full offline CLI flow`, async () => {
+            const result = await harness?.runCase(testCase);
+            (0, vitest_1.expect)(result).toBeDefined();
+            await (0, assertions_1.expectAdapterE2EResultToMatchSnapshot)(testCase, result);
+        }, 300_000);
+    }
+});

package/dist/scripts/__tests__/adapter-e2e/assertions.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterE2ECase, AdapterE2EResult } from '../../adapter-e2e/types';
+export declare const resolveAdapterE2ESnapshotPath: (testCase: AdapterE2ECase) => string;
+export declare const expectAdapterE2EResultToMatchSnapshot: (testCase: AdapterE2ECase, result: AdapterE2EResult) => Promise<void>;

package/dist/scripts/__tests__/adapter-e2e/assertions.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectAdapterE2EResultToMatchSnapshot = exports.resolveAdapterE2ESnapshotPath = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const log_1 = require("../../adapter-e2e/log");
+const runtime_1 = require("../../adapter-e2e/runtime");
+const snapshot_1 = require("../../adapter-e2e/snapshot");
+const resolveAdapterE2ESnapshotPath = (testCase) => (node_path_1.default.resolve(runtime_1.repoRoot, 'scripts/__tests__/adapter-e2e/__snapshots__', `${testCase.id}.snapshot.json`));
+exports.resolveAdapterE2ESnapshotPath = resolveAdapterE2ESnapshotPath;
+const expectOutput = (expectations, result) => {
+    for (const needle of expectations.outputContains ?? []) {
+        (0, vitest_1.expect)(result.stdout).toContain(needle);
+    }
+};
+const expectHooks = (expectations, result) => {
+    const counts = (0, log_1.countHookLogEvents)((0, log_1.parseHookLogEntries)(result.logContent));
+    for (const rule of expectations.hooks ?? []) {
+        const count = counts.get(rule.event) ?? 0;
+        if (rule.count != null) {
+            (0, vitest_1.expect)(count, `hook ${rule.event} count`).toBe(rule.count);
+        }
+        if (rule.minCount != null) {
+            (0, vitest_1.expect)(count, `hook ${rule.event} minCount`).toBeGreaterThanOrEqual(rule.minCount);
+        }
+        if (rule.maxCount != null) {
+            (0, vitest_1.expect)(count, `hook ${rule.event} maxCount`).toBeLessThanOrEqual(rule.maxCount);
+        }
+    }
+};
+const expectMockTrace = (expectations, result) => {
+    const mockTrace = expectations.mockTrace;
+    if (mockTrace == null)
+        return;
+    if (mockTrace.minRequests != null) {
+        (0, vitest_1.expect)(result.mockTrace.length).toBeGreaterThanOrEqual(mockTrace.minRequests);
+    }
+    const toolResponses = result.mockTrace.flatMap(entry => (entry.response.kind === 'tool'
+        ? [entry.response.tool.name]
+        : []));
+    if (mockTrace.maxToolCalls != null) {
+        (0, vitest_1.expect)(toolResponses.length).toBeLessThanOrEqual(mockTrace.maxToolCalls);
+    }
+    for (const toolName of mockTrace.requiredToolNames ?? []) {
+        (0, vitest_1.expect)(toolResponses).toContain(toolName);
+    }
+    if (mockTrace.finalResponseText != null) {
+        (0, vitest_1.expect)(result.mockTrace.some(entry => (entry.response.kind === 'message' &&
+            entry.response.text === mockTrace.finalResponseText))).toBe(true);
+    }
+};
+const expectAdapterE2EResultToMatchSnapshot = (testCase, result) => {
+    (0, vitest_1.expect)(result.exitCode).toBe(0);
+    (0, vitest_1.expect)(testCase.allowedTransports ?? ['wrapper']).toContain(result.transport);
+    expectOutput(testCase.expectations ?? {}, result);
+    expectHooks(testCase.expectations ?? {}, result);
+    expectMockTrace(testCase.expectations ?? {}, result);
+    return (0, vitest_1.expect)((0, snapshot_1.serializeAdapterE2ESnapshot)(result)).toMatchFileSnapshot((0, exports.resolveAdapterE2ESnapshotPath)(testCase));
+};
+exports.expectAdapterE2EResultToMatchSnapshot = expectAdapterE2EResultToMatchSnapshot;

package/dist/scripts/__tests__/adapter-e2e/cases.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterE2ECase, MockModelScenario, ResolvedAdapterE2ECase } from '../../adapter-e2e/types';
+export declare const defineAdapterE2ECase: (testCase: AdapterE2ECase) => AdapterE2ECase;
+export declare const ADAPTER_E2E_CASES: AdapterE2ECase[];
+export declare const resolveAdapterE2ECase: (testCase: AdapterE2ECase) => ResolvedAdapterE2ECase;
+export declare const collectCaseMockScenarios: (cases: AdapterE2ECase[]) => MockModelScenario[];
+export declare const parseAdapterE2ESelection: (value: string | undefined, cases?: AdapterE2ECase[]) => string;
+export declare const resolveSelectedAdapterE2ECases: (selection: string | undefined, cases?: AdapterE2ECase[]) => AdapterE2ECase[];