kennel 0.1.8

package/dist/mcp/config.js

@@ -0,0 +1,171 @@
+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;
+}
+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 } : {}),
+        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) } : {}),
+        toolAliases: toolAliases(config),
+        ...(toolPacks(config) ? { toolPacks: toolPacks(config) } : {}),
+        version: mcp.version ?? '1.0.0',
+    };
+}

package/dist/mcp/data.d.ts

@@ -0,0 +1,14 @@
+import type { AgentToolEntry } from './agent-tools.js';
+export type DocEntry = {
+    content: string;
+    modified: number;
+    path: string;
+    size: number;
+    slug: string;
+    summary: string;
+    title: string;
+};
+export type RepoEntry = Record<string, unknown>;
+export declare function collectDocs(root: string, config: any): DocEntry[];
+export declare function parseRepoRegistry(root: string, config: any): RepoEntry[];
+export declare function writeMcpData(target: string, docs: DocEntry[], repos: RepoEntry[], agentTools: AgentToolEntry[]): void;

package/dist/mcp/data.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { readJson } from '../shared/json.js';
+import { isObject } from '../shared/object.js';
+import { mcpDataConfig, resolveInside } from './config.js';
+const defaultIgnoredDirs = [
+    '.agents',
+    '.git',
+    '.github',
+    '.gtl',
+    '.kennel',
+    '.vitepress',
+    'email-worker',
+    'functions',
+    'mcp',
+    'node_modules',
+    'public',
+    'scripts',
+    'src',
+];
+export function collectDocs(root, config) {
+    return collectMarkdown(root, root, ignoredDirs(config))
+        .map((path) => parseDoc(root, path))
+        .sort((left, right) => left.title.localeCompare(right.title));
+}
+function ignoredDirs(config) {
+    const data = mcpDataConfig(config);
+    return new Set([
+        ...defaultIgnoredDirs,
+        ...(Array.isArray(data.ignoredDirs) ? data.ignoredDirs.map(String) : []),
+    ]);
+}
+function collectMarkdown(root, dir, ignored) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!ignored.has(entry.name)) {
+                files.push(...collectMarkdown(root, path, ignored));
+            }
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith('.md'))
+            files.push(path);
+    }
+    return files;
+}
+function parseDoc(root, path) {
+    const content = readFileSync(path, 'utf8');
+    const relativePath = relative(root, path);
+    const slug = relativePath.replace(/(^|\/)index\.md$/, '$1index').replace(/\.md$/, '').replace(/\//g, '--');
+    const stat = statSync(path);
+    return {
+        content,
+        modified: Math.floor(stat.mtimeMs / 1000),
+        path: relativePath,
+        size: stat.size,
+        slug,
+        summary: summariseMarkdown(content),
+        title: extractTitle(content, relativePath),
+    };
+}
+function extractTitle(content, path) {
+    const titleMatch = content.match(/^title:\s*["']?(.+?)["']?\s*$/m);
+    if (titleMatch?.[1])
+        return titleMatch[1].trim();
+    const headingMatch = content.match(/^#\s+(.+?)\s*$/m);
+    if (headingMatch?.[1])
+        return headingMatch[1].trim();
+    return path.replace(/\.md$/, '').split('/').pop()?.replace(/-/g, ' ') ?? path;
+}
+function summariseMarkdown(content) {
+    const body = content.replace(/^---[\s\S]*?---\s*/, '');
+    for (const block of body.split(/\n\s*\n/)) {
+        const cleaned = block.trim();
+        if (!cleaned || cleaned.startsWith('#') || cleaned.startsWith('|'))
+            continue;
+        const singleLine = cleaned.replace(/\s+/g, ' ');
+        return singleLine.length > 280 ? `${singleLine.slice(0, 280)}...` : singleLine;
+    }
+    return '';
+}
+function repoRegistryPath(root, config) {
+    const data = mcpDataConfig(config);
+    const configured = typeof data.repoRegistryPath === 'string' ? data.repoRegistryPath : 'repos/index.yaml';
+    if (!configured)
+        return null;
+    const path = resolveInside(root, configured, 'mcp repo registry path');
+    return existsSync(path) ? path : null;
+}
+export function parseRepoRegistry(root, config) {
+    const path = repoRegistryPath(root, config);
+    if (!path)
+        return [];
+    const parsed = parseYaml(readFileSync(path, 'utf8'));
+    const repos = Array.isArray(parsed?.repos) ? parsed.repos : [];
+    return repos
+        .filter(isObject)
+        .map((repo) => ({ ...repo }))
+        .sort((left, right) => String(left.name ?? '').localeCompare(String(right.name ?? '')));
+}
+function sameMcpData(existing, docs, repos, agentTools) {
+    if (!isObject(existing))
+        return false;
+    return JSON.stringify(existing.docs) === JSON.stringify(docs)
+        && JSON.stringify(existing.repos) === JSON.stringify(repos)
+        && JSON.stringify(existing.agentTools ?? []) === JSON.stringify(agentTools);
+}
+export function writeMcpData(target, docs, repos, agentTools) {
+    const existing = existsSync(target) ? readJson(target) : null;
+    const generatedAt = sameMcpData(existing, docs, repos, agentTools) && typeof existing.generatedAt === 'string'
+        ? existing.generatedAt
+        : new Date().toISOString();
+    const next = `${JSON.stringify({ generatedAt, docs, repos, agentTools }, null, 2)}\n`;
+    if (existsSync(target) && readFileSync(target, 'utf8') === next)
+        return;
+    writeFileSync(target, next);
+}

package/dist/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/mcp/function-source.js

@@ -0,0 +1,40 @@
+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>;
+  instructions: string;
+  name: string;
+  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/mcp/generate.d.ts

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

package/dist/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/mcp/install-page.d.ts

@@ -0,0 +1 @@
+export declare function writeInstallPage(root: string, config: any): string | undefined;