kennel 0.2.1 → 0.2.2

package/dist/cli/src/deploy/vercel.d.ts

@@ -0,0 +1,3 @@
+import { type ChildCommand } from '../shared/process.js';
+export declare function publishVercelCommand(root: string, projectName: string): ChildCommand;
+export declare function publishVercel(input: string[]): void;

package/dist/cli/src/deploy/vercel.js

@@ -0,0 +1,67 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readJson } from '../shared/json.js';
+import { localBin } from '../shared/package-manager.js';
+import { commandLine } from '../shared/process.js';
+import { packageJsonPath, publicationConfig, publicationDomains, publishBuildCommand, publishTestUrl, } from '../publish/config.js';
+import { splitPublishArgs } from '../publish/options.js';
+import { publishInitVercel } from '../publish/vercel-init.js';
+import { runStaticHttpTest } from './smoke-tests.js';
+function runVercelCommand(root, child, options) {
+    console.log(commandLine(child.command, child.args));
+    if (options.dryRun)
+        return;
+    const result = spawnSync(child.command, child.args, {
+        cwd: root,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}
+export function publishVercelCommand(root, projectName) {
+    const args = ['deploy', '--prod', '--yes', '--project', projectName];
+    const vercel = localBin(root, 'vercel');
+    if (vercel)
+        return { command: vercel, args };
+    return { command: 'npx', args: ['vercel', ...args] };
+}
+function vercelHostname(config, fallback) {
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const hostname = fallback ||
+        domains.primary ||
+        publication.hostname ||
+        publication.domain ||
+        publication.url;
+    return typeof hostname === 'string' ? hostname : '';
+}
+export function publishVercel(input) {
+    const options = splitPublishArgs(input);
+    const setup = publishInitVercel([
+        '--force',
+        '--config',
+        options.configFile,
+        ...(options.hostname ? ['--hostname', options.hostname] : []),
+        options.targetPath,
+    ]);
+    const { root } = setup;
+    const packagePath = packageJsonPath(root);
+    if (!existsSync(packagePath))
+        throw new Error(`No package.json found next to ${setup.configPath}`);
+    const pkg = readJson(packagePath);
+    if (options.build)
+        runVercelCommand(root, publishBuildCommand(root, pkg), options);
+    const publication = publicationConfig(setup.config);
+    const projectName = typeof publication.projectName === 'string'
+        ? publication.projectName
+        : 'kennel-docs';
+    if (options.deploy)
+        runVercelCommand(root, publishVercelCommand(root, projectName), options);
+    const hostname = vercelHostname(setup.config, setup.hostname);
+    if (hostname && !options.skipTest)
+        runStaticHttpTest(root, hostname, options);
+    const url = publishTestUrl(hostname);
+    if (url)
+        console.log(`url ${url}`);
+}

package/dist/cli/src/main.d.ts

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

package/dist/cli/src/main.js

@@ -0,0 +1,9 @@
+import { dispatch } from './cli/dispatch.js';
+delete process.env.NAPI_RS_NATIVE_LIBRARY_PATH;
+try {
+    await dispatch(process.argv);
+}
+catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(2);
+}

package/dist/cli/src/mcp/agent-tools.d.ts

@@ -0,0 +1,8 @@
+export type AgentToolEntry = {
+    agentPath: string;
+    description: string;
+    exportName: string;
+    inputSchema: Record<string, unknown>;
+    name: string;
+};
+export declare function collectAgentTools(root: string, config: any): AgentToolEntry[];

package/dist/cli/src/mcp/agent-tools.js

@@ -0,0 +1,247 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { installMcpConfig, resolveInside } from './config.js';
+export function collectAgentTools(root, config) {
+    const directory = agentToolsDirectory(root, config);
+    if (!directory || !existsSync(directory))
+        return [];
+    const constantsByPath = new Map();
+    const tools = collectTypeScriptFiles(directory)
+        .flatMap((path) => {
+        const source = readFileSync(path, 'utf8');
+        const constants = stringConstants(source);
+        constantsByPath.set(path, constants);
+        return parseAgentTools(source, relative(root, path), constants);
+    })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const seen = new Set();
+    return tools.filter((tool) => {
+        if (seen.has(tool.name))
+            return false;
+        seen.add(tool.name);
+        return true;
+    });
+}
+function agentToolsDirectory(root, config) {
+    const mcp = installMcpConfig(config);
+    const configured = mcp.agentTools ?? config.agentTools;
+    if (configured === false)
+        return null;
+    const directory = typeof configured === 'object' && configured && 'directory' in configured
+        ? String(configured.directory ?? 'agents')
+        : 'agents';
+    return resolveInside(root, directory, 'mcp agent tools directory');
+}
+function collectTypeScriptFiles(directory) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTypeScriptFiles(path));
+            continue;
+        }
+        if (entry.isFile() && /\.m?ts$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+function parseAgentTools(source, agentPath, constants) {
+    const tools = [];
+    const defineToolPattern = /export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*defineTool\s*\(\s*\{/g;
+    let match;
+    while ((match = defineToolPattern.exec(source)) !== null) {
+        const exportName = match[1] ?? '';
+        const objectStart = match.index + match[0].length - 1;
+        const objectEnd = findMatching(source, objectStart, '{', '}');
+        if (objectEnd === -1)
+            continue;
+        const objectSource = source.slice(objectStart, objectEnd + 1);
+        const name = extractStringProperty(objectSource, 'name');
+        if (!name)
+            continue;
+        tools.push({
+            agentPath,
+            description: extractStringProperty(objectSource, 'description')
+                ?? `Agent tool exported from ${agentPath}.`,
+            exportName,
+            inputSchema: parseParametersSchema(objectSource, constants),
+            name,
+        });
+    }
+    return tools;
+}
+function parseParametersSchema(objectSource, constants) {
+    const parameters = extractObjectProperty(objectSource, 'parameters');
+    if (!parameters) {
+        return {
+            additionalProperties: true,
+            properties: {},
+            type: 'object',
+        };
+    }
+    const schema = {
+        additionalProperties: extractBooleanProperty(parameters, 'additionalProperties') ?? true,
+        properties: parseSchemaProperties(parameters, constants),
+        type: 'object',
+    };
+    const required = extractStringArrayProperty(parameters, 'required');
+    if (required.length)
+        schema.required = required;
+    return schema;
+}
+function parseSchemaProperties(parameters, constants) {
+    const propertiesSource = extractObjectProperty(parameters, 'properties');
+    if (!propertiesSource)
+        return {};
+    const properties = {};
+    let index = 1;
+    while (index < propertiesSource.length - 1) {
+        const match = /(?:^|,)\s*([A-Za-z_$][\w$]*|"[^"]+"|'[^']+')\s*:/.exec(propertiesSource.slice(index));
+        if (!match || typeof match.index !== 'number')
+            break;
+        const name = normalisePropertyName(match[1] ?? '');
+        const colon = index + match.index + match[0].length - 1;
+        const valueStart = nextNonWhitespace(propertiesSource, colon + 1);
+        if (valueStart === -1)
+            break;
+        if (propertiesSource[valueStart] !== '{') {
+            index = valueStart + 1;
+            continue;
+        }
+        const valueEnd = findMatching(propertiesSource, valueStart, '{', '}');
+        if (valueEnd === -1)
+            break;
+        properties[name] = parseSchemaProperty(propertiesSource.slice(valueStart, valueEnd + 1), constants);
+        index = valueEnd + 1;
+    }
+    return properties;
+}
+function parseSchemaProperty(source, constants) {
+    const property = {};
+    const type = extractStringProperty(source, 'type');
+    const description = extractStringProperty(source, 'description');
+    const pattern = extractStringOrConstantProperty(source, 'pattern', constants);
+    const defaultValue = extractPrimitiveProperty(source, 'default', constants);
+    if (type)
+        property.type = type;
+    if (description)
+        property.description = description;
+    if (pattern)
+        property.pattern = pattern;
+    if (defaultValue !== undefined)
+        property.default = defaultValue;
+    return property;
+}
+function extractObjectProperty(source, property) {
+    const propertyIndex = source.search(new RegExp(`\\b${escapeRegExp(property)}\\s*:`));
+    if (propertyIndex === -1)
+        return null;
+    const braceStart = source.indexOf('{', propertyIndex);
+    if (braceStart === -1)
+        return null;
+    const braceEnd = findMatching(source, braceStart, '{', '}');
+    return braceEnd === -1 ? null : source.slice(braceStart, braceEnd + 1);
+}
+function extractStringProperty(source, property) {
+    const match = new RegExp(`\\b${escapeRegExp(property)}\\s*:\\s*(["'\`])([\\s\\S]*?)\\1`).exec(source);
+    return match ? decodeStringLiteral(match[2] ?? '') : null;
+}
+function extractStringOrConstantProperty(source, property, constants) {
+    const stringValue = extractStringProperty(source, property);
+    if (stringValue)
+        return stringValue;
+    const match = new RegExp(`\\b${escapeRegExp(property)}\\s*:\\s*([A-Za-z_$][\\w$]*)`).exec(source);
+    return match?.[1] ? constants[match[1]] ?? null : null;
+}
+function extractBooleanProperty(source, property) {
+    const match = new RegExp(`\\b${escapeRegExp(property)}\\s*:\\s*(true|false)\\b`).exec(source);
+    return match ? match[1] === 'true' : null;
+}
+function extractStringArrayProperty(source, property) {
+    const match = new RegExp(`\\b${escapeRegExp(property)}\\s*:\\s*\\[([\\s\\S]*?)\\]`).exec(source);
+    if (!match?.[1])
+        return [];
+    return Array.from(match[1].matchAll(/(["'])([\s\S]*?)\1/g)).map((entry) => decodeStringLiteral(entry[2] ?? ''));
+}
+function extractPrimitiveProperty(source, property, constants) {
+    const stringValue = extractStringOrConstantProperty(source, property, constants);
+    if (stringValue !== null)
+        return stringValue;
+    const match = new RegExp(`\\b${escapeRegExp(property)}\\s*:\\s*(true|false|-?\\d+(?:\\.\\d+)?)\\b`).exec(source);
+    if (!match?.[1])
+        return undefined;
+    if (match[1] === 'true')
+        return true;
+    if (match[1] === 'false')
+        return false;
+    return Number(match[1]);
+}
+function stringConstants(source) {
+    const constants = {};
+    for (const match of source.matchAll(/\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(["'\`])([\s\S]*?)\2/g)) {
+        const name = match[1];
+        const value = match[3];
+        if (name && value !== undefined)
+            constants[name] = decodeStringLiteral(value);
+    }
+    return constants;
+}
+function findMatching(source, start, open, close) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = start; index < source.length; index += 1) {
+        const char = source[index];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            continue;
+        }
+        if (char === open)
+            depth += 1;
+        if (char === close) {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function nextNonWhitespace(source, start) {
+    for (let index = start; index < source.length; index += 1) {
+        if (!/\s/.test(source[index] ?? ''))
+            return index;
+    }
+    return -1;
+}
+function normalisePropertyName(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return decodeStringLiteral(value.slice(1, -1));
+    }
+    return value;
+}
+function decodeStringLiteral(value) {
+    return value
+        .replace(/\\n/g, '\n')
+        .replace(/\\r/g, '\r')
+        .replace(/\\t/g, '\t')
+        .replace(/\\`/g, '`')
+        .replace(/\\"/g, '"')
+        .replace(/\\'/g, "'")
+        .replace(/\\\\/g, '\\');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/cli/src/mcp/config.d.ts

@@ -0,0 +1,25 @@
+export type McpGenerateOptions = {
+    configFile: string;
+    dataOnly: boolean;
+    functionOnly: boolean;
+    targetPath: string;
+};
+export type McpCustomToolConfig = {
+    exportName: string;
+    importPath: string;
+};
+export type McpToolModuleConfig = {
+    exportName: string;
+    importPath: string;
+};
+export declare function splitMcpGenerateArgs(input: string[]): McpGenerateOptions;
+export declare function installMcpConfig(config: any): Record<string, any>;
+export declare function coreMcpConfig(config: any): Record<string, any>;
+export declare function mcpDataConfig(config: any): Record<string, any>;
+export declare function customTools(config: any): McpCustomToolConfig[];
+export declare function toolModules(config: any): McpToolModuleConfig[];
+export declare function agentToolsDirectory(config: any): string | null;
+export declare function resolveInside(root: string, filePath: string, label: string): string;
+export declare function outputPath(root: string, config: any): string;
+export declare function functionPath(root: string, config: any): string;
+export declare function serverConfig(config: any): Record<string, unknown>;

package/dist/cli/src/mcp/config.js

@@ -0,0 +1,185 @@
+import { resolve } from 'node:path';
+import { isObject } from '../shared/object.js';
+import { DEFAULT_PROJECT_CONFIG } from '../shared/project-config.js';
+export function splitMcpGenerateArgs(input) {
+    const options = {
+        configFile: DEFAULT_PROJECT_CONFIG,
+        dataOnly: false,
+        functionOnly: false,
+        targetPath: '.',
+    };
+    for (let index = 0; index < input.length; index += 1) {
+        const arg = input[index];
+        if (arg === '--config') {
+            options.configFile = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--config=')) {
+            options.configFile = arg.slice('--config='.length);
+            continue;
+        }
+        if (arg === '--data-only') {
+            options.dataOnly = true;
+            continue;
+        }
+        if (arg === '--function-only') {
+            options.functionOnly = true;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`Unknown mcp generate option: ${arg}`);
+        options.targetPath = arg;
+    }
+    if (!options.configFile)
+        throw new Error('mcp generate requires a config file name');
+    if (options.dataOnly && options.functionOnly)
+        throw new Error('Use only one of --data-only or --function-only');
+    return options;
+}
+export function installMcpConfig(config) {
+    if (isObject(config.install?.mcp))
+        return config.install.mcp;
+    return {};
+}
+export function coreMcpConfig(config) {
+    return isObject(config.mcp) ? config.mcp : {};
+}
+function runtimeMcpConfig(config) {
+    return {
+        ...installMcpConfig(config),
+        ...coreMcpConfig(config),
+    };
+}
+export function mcpDataConfig(config) {
+    const coreMcp = coreMcpConfig(config);
+    const installMcp = installMcpConfig(config);
+    if (isObject(coreMcp.data))
+        return coreMcp.data;
+    if (isObject(installMcp.data))
+        return installMcp.data;
+    if (isObject(config.mcpData))
+        return config.mcpData;
+    return {};
+}
+export function customTools(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!Array.isArray(mcp.customTools))
+        return [];
+    return mcp.customTools.map((entry, index) => {
+        if (!isObject(entry))
+            throw new Error(`mcp customTools[${index}] must be an object`);
+        const exportName = String(entry.exportName ?? '').trim();
+        const importPath = String(entry.importPath ?? '').trim();
+        if (!/^[A-Za-z_$][\w$]*$/.test(exportName)) {
+            throw new Error(`mcp customTools[${index}].exportName must be a valid import identifier`);
+        }
+        if (!importPath)
+            throw new Error(`mcp customTools[${index}].importPath is required`);
+        return { exportName, importPath };
+    });
+}
+export function toolModules(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!Array.isArray(mcp.toolModules))
+        return [];
+    return mcp.toolModules.map((entry, index) => {
+        if (!isObject(entry))
+            throw new Error(`mcp toolModules[${index}] must be an object`);
+        const exportName = String(entry.exportName ?? '').trim();
+        const importPath = String(entry.importPath ?? '').trim();
+        if (!/^[A-Za-z_$][\w$]*$/.test(exportName)) {
+            throw new Error(`mcp toolModules[${index}].exportName must be a valid import identifier`);
+        }
+        if (!importPath)
+            throw new Error(`mcp toolModules[${index}].importPath is required`);
+        return { exportName, importPath };
+    });
+}
+export function agentToolsDirectory(config) {
+    const mcp = runtimeMcpConfig(config);
+    const configured = mcp.agentTools ?? config.agentTools;
+    if (configured === false)
+        return null;
+    if (isObject(configured) && 'directory' in configured) {
+        return String(configured.directory ?? 'agents');
+    }
+    return 'agents';
+}
+export function resolveInside(root, filePath, label) {
+    const resolvedRoot = resolve(root);
+    const target = resolve(resolvedRoot, filePath);
+    if (target !== resolvedRoot && !target.startsWith(`${resolvedRoot}/`)) {
+        throw new Error(`${label} must resolve inside project root: ${filePath}`);
+    }
+    return target;
+}
+export function outputPath(root, config) {
+    const data = mcpDataConfig(config);
+    const configured = typeof data.outputPath === 'string' && data.outputPath.trim()
+        ? data.outputPath.trim()
+        : 'mcp/_generated/mcp-data.json';
+    return resolveInside(root, configured, 'mcp data output path');
+}
+export function functionPath(root, config) {
+    const mcp = runtimeMcpConfig(config);
+    const configured = typeof mcp.functionPath === 'string' && mcp.functionPath.trim()
+        ? mcp.functionPath.trim()
+        : 'mcp/index.ts';
+    return resolveInside(root, configured, 'mcp function path');
+}
+function toolAliases(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.toolAliases))
+        return {};
+    return Object.fromEntries(Object.entries(mcp.toolAliases).map(([alias, target]) => [alias, String(target)]));
+}
+function repoIntegrations(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.repoIntegrations))
+        return undefined;
+    return mcp.repoIntegrations;
+}
+function access(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.access))
+        return undefined;
+    return mcp.access;
+}
+function toolPacks(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.toolPacks))
+        return undefined;
+    return mcp.toolPacks;
+}
+function toolCatalog(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.toolCatalog))
+        return undefined;
+    return mcp.toolCatalog;
+}
+function docs(config) {
+    const mcp = runtimeMcpConfig(config);
+    if (!isObject(mcp.docs))
+        return undefined;
+    return mcp.docs;
+}
+export function serverConfig(config) {
+    const mcp = runtimeMcpConfig(config);
+    const serverName = String(mcp.serverName ?? config.name ?? 'index');
+    return {
+        ...(access(config) ? { access: access(config) } : {}),
+        ...(isObject(mcp.analytics) ? { analytics: mcp.analytics } : {}),
+        ...(isObject(mcp.conversationSnapshots) ? { conversationSnapshots: mcp.conversationSnapshots } : {}),
+        ...(docs(config) ? { docs: docs(config) } : {}),
+        instructions: typeof mcp.instructions === 'string' && mcp.instructions.trim()
+            ? mcp.instructions.trim()
+            : "Find relevant Index documents and repo entries for the user's topic. Use search_index_docs and search_index_repos for topic lookup, then read index://doc/{slug} or index://repo/{name} when more detail is needed.",
+        name: mcp.runtimeName ?? `${serverName}-mcp`,
+        ...(repoIntegrations(config) ? { repoIntegrations: repoIntegrations(config) } : {}),
+        ...(toolCatalog(config) ? { toolCatalog: toolCatalog(config) } : {}),
+        toolAliases: toolAliases(config),
+        ...(toolPacks(config) ? { toolPacks: toolPacks(config) } : {}),
+        version: mcp.version ?? '1.0.0',
+    };
+}

package/dist/cli/src/mcp/function-source.d.ts

@@ -0,0 +1,7 @@
+import type { McpCustomToolConfig, McpToolModuleConfig } from './config.js';
+export type McpFunctionSourceOptions = {
+    customTools?: McpCustomToolConfig[];
+    serverConfig: Record<string, unknown>;
+    toolModules?: McpToolModuleConfig[];
+};
+export declare function mcpFunctionSource(options: McpFunctionSourceOptions): string;

package/dist/cli/src/mcp/function-source.js

@@ -0,0 +1,42 @@
+export function mcpFunctionSource(options) {
+    const customTools = options.customTools ?? [];
+    const toolModules = options.toolModules ?? [];
+    const customToolImports = customTools
+        .map((tool) => `import { ${tool.exportName} } from ${JSON.stringify(tool.importPath)};`)
+        .join('\n');
+    const toolModuleImports = toolModules
+        .map((toolModule) => `import { ${toolModule.exportName} } from ${JSON.stringify(toolModule.importPath)};`)
+        .join('\n');
+    const customToolNames = customTools.map((tool) => tool.exportName);
+    const toolModuleNames = toolModules.map((toolModule) => toolModule.exportName);
+    const customToolsDeclaration = customToolNames.length || toolModuleNames.length
+        ? `\nconst customTools = [${[
+            ...customToolNames,
+            ...toolModuleNames.map((name) => `...${name}`),
+        ].join(', ')}];\n`
+        : '';
+    const customToolOption = customToolNames.length || toolModuleNames.length ? ', customTools' : '';
+    return `import { createMcpHttpHandler } from "@raggle-ai/kennel/mcp";
+import data from "./_generated/mcp-data.json";
+${customToolImports ? `${customToolImports}\n` : ''}${toolModuleImports ? `${toolModuleImports}\n` : ''}
+
+const serverConfig = ${JSON.stringify(options.serverConfig, null, 2)} as {
+  access?: Record<string, unknown>;
+  analytics?: Record<string, unknown>;
+  conversationSnapshots?: Record<string, unknown>;
+  docs?: Record<string, unknown>;
+  instructions: string;
+  name: string;
+  toolCatalog?: Record<string, unknown>;
+  toolAliases: Record<string, string>;
+  toolPacks?: Record<string, unknown>;
+  version: string;
+};
+${customToolsDeclaration}
+
+const handleMcpRequest = createMcpHttpHandler({ data, serverConfig${customToolOption} });
+
+export const onRequest = async ({ env, request }: { env?: Record<string, unknown>; request: Request }) =>
+  handleMcpRequest(request, env);
+`;
+}

package/dist/cli/src/mcp/generate.d.ts

@@ -0,0 +1 @@
+export declare function generateMcp(input: string[]): Promise<void>;

package/dist/cli/src/mcp/generate.js

@@ -0,0 +1,47 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, relative } from 'node:path';
+import { collectAgentTools, collectMcpData, writeMcpData, } from '@raggle-ai/kennel-mcp/data';
+import { readJson } from '../shared/json.js';
+import { writeNotificationEmailWorker } from '../notifications/email-worker.js';
+import { projectConfigPath } from '../shared/project-config.js';
+import { agentToolsDirectory, customTools, functionPath, mcpDataConfig, outputPath, serverConfig, splitMcpGenerateArgs, toolModules, } from './config.js';
+import { mcpFunctionSource } from './function-source.js';
+import { writeInstallPage } from './install-page.js';
+export async function generateMcp(input) {
+    const options = splitMcpGenerateArgs(input);
+    const configPath = projectConfigPath(options.targetPath, options.configFile);
+    const root = dirname(configPath);
+    const config = readJson(configPath);
+    if (!options.functionOnly) {
+        const installPage = writeInstallPage(root, config);
+        if (installPage)
+            console.log(`ok ${relative(root, installPage)}`);
+        const dataConfig = {
+            ...(Array.isArray(config.srcExclude) ? { srcExclude: config.srcExclude } : {}),
+            ...mcpDataConfig(config),
+        };
+        const agentDirectory = agentToolsDirectory(config);
+        const agentTools = agentDirectory ? collectAgentTools(root, agentDirectory) : [];
+        const { docs, health, repos } = collectMcpData(root, dataConfig);
+        const target = outputPath(root, config);
+        mkdirSync(dirname(target), { recursive: true });
+        writeMcpData(target, docs, repos, agentTools, health);
+        console.log(`ok ${relative(root, target)} (${docs.length} docs, ${repos.length} repos, ${agentTools.length} agent tools)`);
+    }
+    if (!options.dataOnly) {
+        const target = functionPath(root, config);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, mcpFunctionSource({
+            customTools: customTools(config),
+            serverConfig: serverConfig(config),
+            toolModules: toolModules(config),
+        }));
+        console.log(`ok ${relative(root, target)}`);
+        const emailWorker = writeNotificationEmailWorker(root, config, configPath);
+        if (emailWorker) {
+            console.log(`ok ${relative(root, emailWorker.workerPath)}`);
+            console.log(`ok ${relative(root, emailWorker.testPath)}`);
+            console.log(`ok ${relative(root, emailWorker.wranglerPath)}`);
+        }
+    }
+}

package/dist/cli/src/mcp/install-page.d.ts

@@ -0,0 +1,12 @@
+import { installPageLink, installPageMarkdownPath, renderInstallPage } from '@raggle-ai/kennel-knowledge/install-page';
+export { installPageLink, installPageMarkdownPath, renderInstallPage, };
+export type InstallModel = {
+    description: string;
+    displayName: string;
+    installMarkdownUrl?: string;
+    protectedUrl?: string;
+    publicUrl: string;
+    serverName: string;
+    tools: string[];
+};
+export declare function writeInstallPage(root: string, config: Record<string, unknown>): string | undefined;

package/dist/cli/src/mcp/install-page.js

@@ -0,0 +1,5 @@
+import { installPageLink, installPageMarkdownPath, renderInstallPage, writeInstallPage as writeSharedInstallPage, } from '@raggle-ai/kennel-knowledge/install-page';
+export { installPageLink, installPageMarkdownPath, renderInstallPage, };
+export function writeInstallPage(root, config) {
+    return writeSharedInstallPage(config, root);
+}