@vobs/cli 0.1.0 → 0.3.0

package/dist/ai-server.d.ts

@@ -0,0 +1,11 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+export interface VobsAiServerStreams {
+    readonly input: AsyncIterable<string>;
+    readonly stdout: Pick<NodeJS.WriteStream, 'write'>;
+    readonly stderr?: Pick<NodeJS.WriteStream, 'write'>;
+}
+/** Serve the read-only vobs AI tools over line-delimited JSON-RPC on stdio. */
+export declare function runVobsAiServer(streams: VobsAiServerStreams): Promise<void>;

package/dist/ai-server.js

@@ -0,0 +1,212 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { existsSync, realpathSync } from 'node:fs';
+import * as path from 'node:path';
+import { VOBS_AI_TOOL_CATALOG, } from '@vobs/ai-contracts';
+import { createVobsProjectContext } from './context.js';
+import { createVobsDiagnosticReport } from './diagnose.js';
+import { inspectVobsProject } from './inspect.js';
+const MCP_PROTOCOL_VERSION = '2025-06-18';
+const SERVER_VERSION = '0.1.0';
+/** Serve the read-only vobs AI tools over line-delimited JSON-RPC on stdio. */
+export async function runVobsAiServer(streams) {
+    for await (const line of streams.input) {
+        if (line.trim() === '')
+            continue;
+        const response = await handleJsonRpcLine(line);
+        if (response === undefined)
+            continue;
+        streams.stdout.write(`${JSON.stringify(response)}\n`);
+    }
+}
+async function handleJsonRpcLine(line) {
+    let request;
+    try {
+        request = JSON.parse(line);
+    }
+    catch {
+        return errorResponse(null, -32700, 'Parse error');
+    }
+    if (request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+        return errorResponse(request.id ?? null, -32600, 'Invalid Request');
+    }
+    if (request.id === undefined) {
+        await Promise.resolve()
+            .then(() => dispatchRequest(request))
+            .catch(() => undefined);
+        return undefined;
+    }
+    try {
+        return {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: await dispatchRequest(request),
+        };
+    }
+    catch (error) {
+        if (error instanceof AiToolRequestError) {
+            return errorResponse(request.id, error.code, error.message);
+        }
+        return errorResponse(request.id, -32603, 'Internal error');
+    }
+}
+function dispatchRequest(request) {
+    switch (request.method) {
+        case 'initialize':
+            return initializeResult();
+        case 'notifications/initialized':
+            return undefined;
+        case 'ping':
+            return {};
+        case 'tools/list':
+            return { tools: VOBS_AI_TOOL_CATALOG.tools };
+        case 'tools/call':
+            return callTool(request.params);
+        default:
+            throw new AiToolRequestError(-32601, `Method not found: ${String(request.method)}`);
+    }
+}
+function initializeResult() {
+    return {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: 'vobs-ai', version: SERVER_VERSION },
+    };
+}
+function callTool(params) {
+    if (!isRecord(params) || typeof params.name !== 'string') {
+        throw new AiToolRequestError(-32602, 'tools/call requires a tool name');
+    }
+    const input = params.arguments === undefined ? {} : params.arguments;
+    if (!isRecord(input)) {
+        throw new AiToolRequestError(-32602, 'tools/call arguments must be an object');
+    }
+    let output;
+    try {
+        output = invokeTool(params.name, input);
+    }
+    catch (error) {
+        if (error instanceof AiToolRequestError)
+            throw error;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: error instanceof Error ? error.message : 'The vobs tool failed.',
+                },
+            ],
+            structuredContent: null,
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(output) }],
+        structuredContent: output,
+        isError: false,
+    };
+}
+function invokeTool(name, input) {
+    if (!VOBS_AI_TOOL_CATALOG.tools.some((tool) => tool.name === name)) {
+        throw new AiToolRequestError(-32602, `Unknown tool: ${name}`);
+    }
+    assertKnownToolInput(name, input);
+    const tsconfigPath = readOptionalString(input, 'tsconfig');
+    const route = readOptionalString(input, 'route');
+    const file = readOptionalString(input, 'file');
+    const depth = readOptionalInteger(input, 'depth');
+    const resolvedTsconfig = resolveToolTsconfig(tsconfigPath);
+    switch (name) {
+        case 'project.inspect':
+            if (route !== undefined || file !== undefined || depth !== undefined) {
+                throw new AiToolRequestError(-32602, 'project.inspect only accepts tsconfig');
+            }
+            return inspectVobsProject({ tsconfigPath: resolvedTsconfig });
+        case 'project.context':
+            if (route === undefined && file === undefined) {
+                throw new AiToolRequestError(-32602, 'project.context requires route or file');
+            }
+            if (route !== undefined && file !== undefined) {
+                throw new AiToolRequestError(-32602, 'project.context accepts only one selector');
+            }
+            return createVobsProjectContext({
+                tsconfigPath: resolvedTsconfig,
+                ...(route === undefined ? {} : { route }),
+                ...(file === undefined ? {} : { file }),
+                ...(depth === undefined ? {} : { depth }),
+            });
+        case 'project.diagnostics':
+            if (route === undefined && file === undefined && depth !== undefined) {
+                throw new AiToolRequestError(-32602, 'project.diagnostics depth requires route or file');
+            }
+            if (route !== undefined && file !== undefined) {
+                throw new AiToolRequestError(-32602, 'project.diagnostics accepts only one selector');
+            }
+            return createVobsDiagnosticReport({
+                tsconfigPath: resolvedTsconfig,
+                ...(route === undefined ? {} : { route }),
+                ...(file === undefined ? {} : { file }),
+                ...(depth === undefined ? {} : { depth }),
+            });
+        default:
+            throw new AiToolRequestError(-32602, `Unknown tool: ${name}`);
+    }
+}
+function assertKnownToolInput(name, input) {
+    const definition = VOBS_AI_TOOL_CATALOG.tools.find((tool) => tool.name === name);
+    if (definition === undefined)
+        return;
+    const allowed = new Set(Object.keys(definition.inputSchema.properties));
+    const unexpected = Object.keys(input).find((key) => !allowed.has(key));
+    if (unexpected !== undefined) {
+        throw new AiToolRequestError(-32602, `Unknown argument for ${name}: ${unexpected}`);
+    }
+}
+function resolveToolTsconfig(tsconfigPath) {
+    const serverRoot = realpathSync.native(process.cwd());
+    const requested = path.resolve(serverRoot, tsconfigPath ?? 'tsconfig.json');
+    if (!isPathInside(serverRoot, requested)) {
+        throw new AiToolRequestError(-32602, 'tsconfig must stay inside the AI server project');
+    }
+    if (existsSync(requested) && !isPathInside(serverRoot, realpathSync.native(requested))) {
+        throw new AiToolRequestError(-32602, 'tsconfig must stay inside the AI server project');
+    }
+    return requested;
+}
+function isPathInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+function readOptionalString(input, key) {
+    const value = input[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new AiToolRequestError(-32602, `${key} must be a non-empty string`);
+    }
+    return value;
+}
+function readOptionalInteger(input, key) {
+    const value = input[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 4) {
+        throw new AiToolRequestError(-32602, `${key} must be an integer from 0 to 4`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function errorResponse(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+}
+class AiToolRequestError extends Error {
+    code;
+    name = 'AiToolRequestError';
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import type { VobsProjectContext } from '@vobs/ai-contracts';
+export interface ContextOptions {
+    readonly tsconfigPath: string;
+    readonly route?: string;
+    readonly file?: string;
+    readonly depth?: number;
+}
+export declare function createVobsProjectContext(options: ContextOptions): VobsProjectContext;

package/dist/context.js

@@ -0,0 +1,301 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { inspectVobsProject } from './inspect.js';
+const MAX_CONTEXT_FILES = 100;
+const ignoredPathSegments = new Set(['.git', '.cache', '.tmp', 'coverage', 'dist', 'node_modules']);
+export function createVobsProjectContext(options) {
+    if ((options.route === undefined) === (options.file === undefined)) {
+        throw new Error('vobs context requires exactly one of --route or --file');
+    }
+    const depth = options.depth ?? 2;
+    if (!Number.isInteger(depth) || depth < 0 || depth > 4) {
+        throw new Error('vobs context --depth must be an integer from 0 to 4');
+    }
+    const tsconfigPath = path.resolve(options.tsconfigPath);
+    const projectRoot = path.dirname(tsconfigPath);
+    const workspaceRoot = findWorkspaceRoot(projectRoot);
+    const manifest = inspectVobsProject({ tsconfigPath });
+    const files = new Map();
+    let truncated = false;
+    const addFile = (file, kind, reason) => {
+        const current = files.get(file);
+        if (current !== undefined) {
+            current.kinds.add(kind);
+            current.reasons.add(reason);
+            return false;
+        }
+        if (files.size >= MAX_CONTEXT_FILES) {
+            truncated = true;
+            return false;
+        }
+        files.set(file, { kinds: new Set([kind]), reasons: new Set([reason]) });
+        return true;
+    };
+    let selectedFile;
+    let selectedRoutes;
+    if (options.route !== undefined) {
+        const route = findRoute(manifest.files.routes, options.route);
+        if (route === undefined)
+            throw new Error(`No vobs route matches: ${options.route}`);
+        selectedRoutes = [route];
+    }
+    else {
+        const absoluteFile = path.resolve(projectRoot, options.file);
+        assertProjectSourceFile(projectRoot, absoluteFile);
+        selectedFile = manifestPath(absoluteFile, workspaceRoot);
+        addFile(selectedFile, classifyFile(selectedFile, manifest), 'selected file');
+        const ownerFiles = new Set([selectedFile]);
+        for (const component of manifest.files.components) {
+            if (component.file === selectedFile || component.view === selectedFile) {
+                ownerFiles.add(component.file);
+                addFile(component.file, component.kind, `owner related to ${selectedFile}`);
+                if (component.view !== undefined)
+                    addFile(component.view, 'view', `view owned by ${component.file}`);
+            }
+        }
+        selectedRoutes = manifest.files.routes.filter((route) => ownerFiles.has(route.file) ||
+            route.layouts.includes(selectedFile) ||
+            route.error === selectedFile);
+    }
+    for (const route of selectedRoutes)
+        addRouteFiles(route, addFile);
+    const componentByFile = new Map(manifest.files.components.map((component) => [component.file, component]));
+    const viewByFile = new Map((manifest.files.viewContracts ?? []).map((view) => [view.file, view]));
+    const knownViews = new Set(manifest.files.views);
+    const queue = [];
+    const queued = new Set();
+    for (const file of files.keys())
+        enqueue(file, 0, queue, queued);
+    for (let index = 0; index < queue.length; index += 1) {
+        const current = queue[index];
+        if (current === undefined)
+            continue;
+        const component = componentByFile.get(current.file);
+        if (component?.view !== undefined) {
+            const added = addFile(component.view, 'view', `view owned by ${component.file}`);
+            if (added)
+                enqueue(component.view, current.depth, queue, queued);
+        }
+        const view = viewByFile.get(current.file);
+        if (view !== undefined) {
+            for (const include of view.includes) {
+                if (!knownViews.has(include))
+                    continue;
+                const added = addFile(include, 'view', `included by ${view.file}`);
+                if (added)
+                    enqueue(include, current.depth, queue, queued);
+            }
+        }
+        if (current.depth >= depth || !isTypeScriptPath(current.file))
+            continue;
+        const absoluteFile = path.resolve(workspaceRoot, current.file);
+        for (const dependency of readLocalDependencies(absoluteFile, projectRoot, workspaceRoot)) {
+            const added = addFile(dependency, classifyFile(dependency, manifest), `imported by ${current.file}`);
+            if (added)
+                enqueue(dependency, current.depth + 1, queue, queued);
+        }
+    }
+    for (const component of manifest.files.components) {
+        if (component.view !== undefined && files.has(component.view)) {
+            addFile(component.file, component.kind, `owner of ${component.view}`);
+        }
+    }
+    for (const [file, entry] of files) {
+        addKnownKinds(file, entry.kinds, manifest);
+    }
+    const contextFiles = [...files]
+        .map(([file, entry]) => ({
+        path: file,
+        kinds: [...entry.kinds].sort(),
+        reasons: [...entry.reasons].sort(),
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const includedPaths = new Set(contextFiles.map((file) => file.path));
+    const diagnostics = manifest.diagnostics.filter((diagnostic) => diagnostic.source !== undefined && includedPaths.has(diagnostic.source));
+    return {
+        schemaVersion: manifest.schemaVersion,
+        generatedBy: 'vobs context',
+        selector: options.route === undefined
+            ? { file: selectedFile }
+            : { route: normalizeRouteInput(options.route) },
+        project: manifest.project,
+        routes: selectedRoutes,
+        files: contextFiles,
+        components: manifest.files.components.filter((component) => includedPaths.has(component.file) ||
+            (component.view !== undefined && includedPaths.has(component.view))),
+        globalComponents: manifest.files.globalComponents ?? [],
+        views: (manifest.files.viewContracts ?? []).filter((view) => includedPaths.has(view.file)),
+        authorization: manifest.files.authorization.filter((file) => includedPaths.has(file.file)),
+        diagnostics,
+        summary: {
+            fileCount: contextFiles.length,
+            diagnosticCount: diagnostics.length,
+            truncated,
+        },
+    };
+}
+function addRouteFiles(route, addFile) {
+    addFile(route.file, route.kind === 'page' ? 'route' : route.kind, `route ${route.path}`);
+    for (const layout of route.layouts)
+        addFile(layout, 'layout', `layout for route ${route.path}`);
+    if (route.error !== undefined)
+        addFile(route.error, 'error', `error boundary for route ${route.path}`);
+}
+function findRoute(routes, routeInput) {
+    const normalized = normalizeRouteInput(routeInput);
+    const exact = routes.find((route) => route.path === normalized);
+    if (exact !== undefined)
+        return exact;
+    return routes
+        .filter((route) => route.kind === 'page' && routeMatches(route.path, normalized))
+        .sort((left, right) => routeSpecificity(right.path) - routeSpecificity(left.path))[0];
+}
+function normalizeRouteInput(route) {
+    const pathOnly = route.split(/[?#]/u)[0] ?? '';
+    if (pathOnly === '')
+        return '/';
+    const prefixed = pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`;
+    return prefixed.length > 1 ? prefixed.replace(/\/+$/u, '') : prefixed;
+}
+function routeMatches(pattern, route) {
+    const patternSegments = routeSegments(pattern);
+    const routeParts = routeSegments(route);
+    for (let index = 0; index < patternSegments.length; index += 1) {
+        const patternSegment = patternSegments[index];
+        const routeSegment = routeParts[index];
+        if (patternSegment?.startsWith('*'))
+            return routeSegment !== undefined;
+        if (routeSegment === undefined)
+            return false;
+        if (!patternSegment?.startsWith(':') && patternSegment !== routeSegment)
+            return false;
+    }
+    return patternSegments.length === routeParts.length;
+}
+function routeSegments(route) {
+    return route === '/' ? [] : route.split('/').filter(Boolean);
+}
+function routeSpecificity(route) {
+    return routeSegments(route).reduce((score, segment) => score + (segment.startsWith('*') ? 0 : segment.startsWith(':') ? 1 : 2), 0);
+}
+function readLocalDependencies(fileName, projectRoot, workspaceRoot) {
+    if (!existsSync(fileName))
+        return [];
+    const source = readFileSync(fileName, 'utf8');
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const dependencies = new Set();
+    const visit = (node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier !== undefined &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            addResolvedDependency(node.moduleSpecifier.text);
+        }
+        else if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            node.arguments[0] !== undefined &&
+            ts.isStringLiteral(node.arguments[0])) {
+            addResolvedDependency(node.arguments[0].text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    const addResolvedDependency = (request) => {
+        if (!request.startsWith('.'))
+            return;
+        const dependency = resolveSourceRequest(path.dirname(fileName), request);
+        if (dependency === undefined || !isPathInside(projectRoot, dependency))
+            return;
+        dependencies.add(manifestPath(dependency, workspaceRoot));
+    };
+    visit(sourceFile);
+    return [...dependencies].sort();
+}
+function resolveSourceRequest(directory, request) {
+    const requested = path.resolve(directory, request);
+    const extension = path.extname(requested);
+    const candidates = [
+        requested,
+        ...(extension === '.js' || extension === '.mjs'
+            ? [
+                `${requested.slice(0, -extension.length)}.ts`,
+                `${requested.slice(0, -extension.length)}.tsx`,
+            ]
+            : []),
+        ...(extension === ''
+            ? [
+                `${requested}.ts`,
+                `${requested}.tsx`,
+                `${requested}.html`,
+                path.join(requested, 'index.ts'),
+            ]
+            : []),
+    ];
+    return candidates.find((candidate) => isContextSourcePath(candidate) && existsSync(candidate) && statSync(candidate).isFile());
+}
+function assertProjectSourceFile(projectRoot, fileName) {
+    if (!isPathInside(projectRoot, fileName)) {
+        throw new Error(`vobs context file must stay inside the project: ${fileName}`);
+    }
+    if (!isContextSourcePath(fileName) || !existsSync(fileName) || !statSync(fileName).isFile()) {
+        throw new Error(`vobs context file is not a supported project source: ${fileName}`);
+    }
+}
+function isContextSourcePath(fileName) {
+    const segments = path.resolve(fileName).split(path.sep);
+    return (!segments.some((segment) => ignoredPathSegments.has(segment)) &&
+        !segments.some((segment) => /^(?:\.env|.*(?:secret|token|credential|password).*)$/iu.test(segment)) &&
+        (fileName.endsWith('.ts') || fileName.endsWith('.tsx') || fileName.endsWith('.html')));
+}
+function isTypeScriptPath(fileName) {
+    return fileName.endsWith('.ts') || fileName.endsWith('.tsx');
+}
+function isPathInside(root, fileName) {
+    const relative = path.relative(root, fileName);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+function enqueue(file, depth, queue, queued) {
+    if (queued.has(file))
+        return;
+    queued.add(file);
+    queue.push({ file, depth });
+}
+function classifyFile(file, manifest) {
+    const component = manifest.files.components.find((candidate) => candidate.file === file || candidate.view === file);
+    if (component?.view === file)
+        return 'view';
+    if (component !== undefined)
+        return component.kind;
+    if (manifest.files.authorization.some((candidate) => candidate.file === file)) {
+        return 'authorization';
+    }
+    return 'dependency';
+}
+function addKnownKinds(file, kinds, manifest) {
+    const component = manifest.files.components.find((candidate) => candidate.file === file);
+    if (component !== undefined)
+        kinds.add(component.kind);
+    if (manifest.files.components.some((candidate) => candidate.view === file))
+        kinds.add('view');
+    if (manifest.files.authorization.some((candidate) => candidate.file === file)) {
+        kinds.add('authorization');
+    }
+}
+function findWorkspaceRoot(start) {
+    let current = path.resolve(start);
+    while (true) {
+        if (existsSync(path.join(current, 'pnpm-workspace.yaml')))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return path.resolve(start);
+        current = parent;
+    }
+}
+function manifestPath(fileName, workspaceRoot) {
+    const relative = path.relative(workspaceRoot, fileName).replaceAll(path.sep, '/');
+    return relative === '' ? '.' : relative;
+}

package/dist/diagnose.d.ts

@@ -0,0 +1,12 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { type VobsProjectDiagnosticReport } from '@vobs/ai-contracts';
+export interface DiagnoseOptions {
+    readonly tsconfigPath: string;
+    readonly route?: string;
+    readonly file?: string;
+    readonly depth?: number;
+}
+export declare function createVobsDiagnosticReport(options: DiagnoseOptions): VobsProjectDiagnosticReport;

package/dist/diagnose.js

@@ -0,0 +1,122 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { VOBS_AI_SCHEMA_VERSION, VOBS_COMPILER_DIAGNOSTIC_GUIDANCE, } from '@vobs/ai-contracts';
+import { createVobsProjectContext } from './context.js';
+import { inspectVobsProject } from './inspect.js';
+const unknownDiagnosticGuidance = {
+    area: 'compiler',
+    summary: 'The compiler reported a diagnostic without registered AI guidance.',
+    actions: [
+        'Inspect the diagnostic message and reported source location.',
+        'Look up the diagnostic code in the vobs error reference.',
+        'Run vobs check after making a focused change.',
+    ],
+    documentation: '/reference/errors/',
+};
+export function createVobsDiagnosticReport(options) {
+    if (options.route !== undefined && options.file !== undefined) {
+        throw new Error('vobs diagnose accepts at most one of --route or --file');
+    }
+    if (options.depth !== undefined && options.route === undefined && options.file === undefined) {
+        throw new Error('vobs diagnose --depth requires --route or --file');
+    }
+    let selector;
+    let project;
+    let diagnostics;
+    let relationships;
+    let truncated = false;
+    if (options.route !== undefined || options.file !== undefined) {
+        const context = createVobsProjectContext(options);
+        selector = context.selector;
+        project = context.project;
+        diagnostics = context.diagnostics;
+        truncated = context.summary.truncated;
+        relationships = {
+            components: context.components,
+            views: context.views ?? [],
+            routes: context.routes,
+        };
+    }
+    else {
+        const manifest = inspectVobsProject({ tsconfigPath: options.tsconfigPath });
+        project = manifest.project;
+        diagnostics = manifest.diagnostics;
+        relationships = {
+            components: manifest.files.components,
+            views: manifest.files.viewContracts ?? [],
+            routes: manifest.files.routes,
+        };
+    }
+    const guidedDiagnostics = diagnostics.map((diagnostic) => guideDiagnostic(diagnostic, relationships));
+    return {
+        schemaVersion: VOBS_AI_SCHEMA_VERSION,
+        generatedBy: 'vobs diagnose',
+        ...(selector === undefined ? {} : { selector }),
+        project,
+        diagnostics: guidedDiagnostics,
+        summary: {
+            total: guidedDiagnostics.length,
+            errors: countSeverity(guidedDiagnostics, 'error'),
+            warnings: countSeverity(guidedDiagnostics, 'warning'),
+            infos: countSeverity(guidedDiagnostics, 'info'),
+            truncated,
+        },
+    };
+}
+function guideDiagnostic(diagnostic, relationships) {
+    return {
+        ...diagnostic,
+        guidance: VOBS_COMPILER_DIAGNOSTIC_GUIDANCE[diagnostic.code] ?? unknownDiagnosticGuidance,
+        relatedFiles: collectRelatedFiles(diagnostic.source, relationships),
+    };
+}
+function collectRelatedFiles(source, relationships) {
+    if (source === undefined)
+        return [];
+    const related = new Set([source]);
+    addRelatedComponents(related, relationships.components);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const view of relationships.views) {
+            if (related.has(view.file)) {
+                for (const include of view.includes) {
+                    if (!related.has(include)) {
+                        related.add(include);
+                        changed = true;
+                    }
+                }
+            }
+            if (view.includes.some((include) => related.has(include)) && !related.has(view.file)) {
+                related.add(view.file);
+                changed = true;
+            }
+        }
+    }
+    addRelatedComponents(related, relationships.components);
+    for (const route of relationships.routes) {
+        if (route.file !== source && route.error !== source && !route.layouts.includes(source)) {
+            continue;
+        }
+        related.add(route.file);
+        for (const layout of route.layouts)
+            related.add(layout);
+        if (route.error !== undefined)
+            related.add(route.error);
+    }
+    return [...related].sort();
+}
+function addRelatedComponents(related, components) {
+    for (const component of components) {
+        if (!related.has(component.file) && !related.has(component.view ?? ''))
+            continue;
+        related.add(component.file);
+        if (component.view !== undefined)
+            related.add(component.view);
+    }
+}
+function countSeverity(diagnostics, severity) {
+    return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}