kennel 0.2.13 → 0.2.15

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

@@ -1,247 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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);
-}

package/dist/cli/src/notifications/email-worker.d.ts

@@ -1,8 +0,0 @@
-type GeneratedNotificationWorker = {
-    testPath: string;
-    workerPath: string;
-    wranglerPath: string;
-};
-export declare function writeNotificationEmailWorker(root: string, config: any, configPath: string): GeneratedNotificationWorker | null;
-export declare function notificationEmailConfig(config: any): Record<string, any> | null;
-export {};