kennel 0.1.8 → 0.1.9

package/README.md

@@ -1,8 +1,6 @@
-# Kennel CLI
+# Kennel Platform CLI
 
-Schema-backed folder ledger validator for structured workspaces.
-
-Kennel keeps structured folders easy to inspect and validate. It looks upward from the target path for the nearest `schema.json` or `_schema.json`, then validates schema-declared YAML files or Markdown frontmatter documents.
+Publishing, MCP generation, and knowledge-source commands for Kennel workspaces. The compact schema validator has moved to the private [`raggle-ai/kennel-compact`](https://github.com/raggle-ai/kennel-compact) repository.
 
 ## Usage
 
@@ -12,43 +10,23 @@ npm test
 node bin/kennel.mjs --help
 ```
 
-Install locally from this checkout:
-
-```bash
-npm install /Users/andrew/Documents/GitHub/kennel/cli
-kennel --help
-```
-
-Install from npm after publication:
+Install from npm:
 
 ```bash
 npm install --global kennel
 kennel --help
 ```
 
-Publish to npm:
+Run platform commands:
 
 ```bash
-cd /Users/andrew/Documents/GitHub/kennel/cli
-npm publish --access public --registry=https://registry.npmjs.org
-```
-
-Run against folder schemas:
-
-```bash
-kennel schema clients/reapit
-kennel validate clients
-kennel validate projects
-kennel validate partners
-kennel doctor clients/reapit
 kennel dev /Users/andrewmagu/src/cdp-index --config index.json
+kennel mcp generate . --config index.json
 kennel publish init cloudflare .
 kennel deploy .
 kennel dp .
 ```
 
-Kennel does not create schemas or new records. Manage `schema.json` or `_schema.json` files and folder templates outside the CLI, then use Kennel to inspect and validate them.
-
 `kennel publish init cloudflare` is the exception for deploy wiring: it scaffolds
 a Cloudflare Worker email-code gate for an existing docs workspace by writing
 `publication` in `raggle.json` by default, then writing generated Cloudflare
@@ -67,65 +45,6 @@ Kennel loads `CLOUDFLARE_API_TOKEN` from Doppler only for the publish command.
 `kennel publish cloudflare` remains available when the provider should be
 explicit.
 
-## Folder Shape
-
-```text
-clients/
-  schema.json
-  example-client/
-    client.yml
-    people/
-    notes/
-    comms/
-    evidence/
-```
-
-The nearest parent `schema.json` or `_schema.json` owns the expected shape for folders below it. When both names exist in the same folder, `schema.json` is preferred.
-
-`kennel validate` discovers files from the nearest schema's `x-kennel.documents` declaration. If a schema omits that declaration, Kennel keeps the compatibility default of `client.yml` and `index.md`.
-
-Markdown files are validated using YAML frontmatter. YAML files are parsed as YAML.
-
-## Folder Requirements
-
-Schemas can include a Kennel-only extension for folder shape checks:
-
-```json
-{
-  "x-kennel": {
-    "documents": [
-      "client.yml",
-      { "path": "index.md", "parser": "markdown-frontmatter" },
-      { "glob": "*.yml", "parser": "yaml" }
-    ],
-    "requiredDirectories": ["people", "notes", "comms", "evidence"],
-    "requiredFiles": ["README.md"],
-    "directoryContents": [
-      {
-        "path": "people",
-        "glob": "*.md",
-        "minFiles": 1,
-        "whenPointerMinItems": "/contacts"
-      }
-    ],
-    "fileReferences": [
-      {
-        "pointer": "/contacts/*/path",
-        "required": true,
-        "whenPointerMinItems": "/contacts"
-      }
-    ]
-  }
-}
-```
-
-String document entries match a file name anywhere under the schema root. Object entries can use `path` or `glob` plus an optional parser.
-
-`requiredDirectories` and `requiredFiles` are checked next to each validated document and by `kennel doctor`.
-
-`directoryContents` checks that a sibling directory contains enough matching files. Use `whenPointerMinItems` to apply the rule only when an array in the document is non-empty, or `whenPointerIn` with `{ "pointer": "/client/status", "values": ["active-client"] }` to apply it for selected field values.
-
-`fileReferences` checks that document path fields point to existing files under the same folder. It supports JSON pointers with `*` wildcards, such as `/contacts/*/path`.
 
 ## MCP Analytics
 
@@ -158,7 +77,7 @@ The Raggle provider uses the `raggle-otel` package and defaults to `RAGGLE_OTEL_
 
 ## MCP Repo Integrations
 
-`kennel mcp generate` also emits an MCP server runtime (`@raggle-ai/kennel-mcp`) with core tools for searching index docs and tracked repositories. The runtime additionally exposes repo integration tools that let an agent run basic GitHub or GitLab commands against a repository linked from the index registry (`repos/index.yaml`):
+`kennel mcp generate` also emits an MCP server runtime from `@raggle-ai/kennel/mcp` with core tools for searching index docs and tracked repositories. The runtime additionally exposes repo integration tools that let an agent run basic GitHub or GitLab commands against a repository linked from the index registry (`repos/index.yaml`):
 
 - `submit_repo_feature_request` — open a feature request issue on a tracked repo, submitted on behalf of a user.
 - `list_repo_issues` — list recent issues on a tracked repo.
@@ -190,6 +109,36 @@ To let people supply their own GitHub or GitLab setup (custom token env, self-ho
 
 `allowedRepos` is an optional allowlist of registry repo names; when omitted, every registry repo is available. Set `enabled: false` to disable the repo integration tools while keeping the rest of the MCP server active.
 
+## MCP Tool Catalog Profiles
+
+Large MCP servers can expose a small eager tool surface while keeping specialised tools discoverable. Add `mcp.toolCatalog` to select a default profile. Tools not selected as eager are deferred automatically; `search_index_tools`, `describe_index_tool`, and `call_index_tool` let an agent discover a deferred schema and invoke it through the catalog dispatcher.
+
+```json
+{
+  "mcp": {
+    "toolCatalog": {
+      "defaultProfile": "minimal",
+      "allowClientProfile": true,
+      "profiles": {
+        "minimal": {
+          "eagerTools": [
+            "search_index",
+            "search_index_tools",
+            "describe_index_tool",
+            "call_index_tool"
+          ]
+        },
+        "complete": {
+          "eagerNamespaces": ["*"]
+        }
+      }
+    }
+  }
+}
+```
+
+When `allowClientProfile` is enabled, an MCP client or gateway can select a configured view with the `x-kennel-mcp-profile` header. Profile selection only narrows catalog exposure: role checks and mutating-tool policy still run for direct and dispatched calls. If `toolCatalog` is omitted, the runtime retains the legacy behavior and lists every available tool.
+
 Registry entries that should support issue creation need a `url` (and optionally `provider`):
 
 ```yaml

package/bin/kennel-native.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { extensionHost } from '../dist/site/extension.js';
+
+extensionHost();

package/dist/cli/dispatch.js

@@ -1,51 +1,60 @@
-import { deploy, publish } from '../deploy/cloudflare.js';
-import { generateMcp } from '../mcp/generate.js';
-import { doctor } from '../schema/doctor.js';
-import { schemaFor, validateTarget } from '../schema/validation.js';
-import { dev } from '../site/dev.js';
-import { publishInitCloudflare } from '../publish/cloudflare-init.js';
 import { usage } from './usage.js';
 export async function dispatch(argv) {
     const [, , command, ...args] = argv;
-    if (!command || command === '-h' || command === '--help') {
+    if (command === '-h' || command === '--help') {
         usage();
         return;
     }
-    if (command === 'schema') {
-        schemaFor(args[0] ?? '.');
+    if (!command) {
+        const { viewer } = await import('../site/viewer.js');
+        await viewer([]);
         return;
     }
-    if (command === 'validate') {
-        const valid = validateTarget(args[0] ?? '.');
-        process.exit(valid ? 0 : 1);
-    }
-    if (command === 'doctor') {
-        doctor(args[0] ?? '.');
+    if (command === 'source') {
+        const { sourceCommand } = await import('../sources/commands.js');
+        sourceCommand(args);
         return;
     }
     if (command === 'dev') {
+        const { dev } = await import('../site/dev.js');
         dev(args);
         return;
     }
+    if (command === 'extension' && args[0] === 'install') {
+        const { extensionInstall } = await import('../site/extension.js');
+        await extensionInstall();
+        return;
+    }
     if (command === 'mcp' && args[0] === 'generate') {
+        const { generateMcp } = await import('../mcp/generate.js');
         await generateMcp(args.slice(1));
         return;
     }
     if (command === 'publish' && args[0] === 'init' && args[1] === 'cloudflare') {
+        const { publishInitCloudflare } = await import('../publish/cloudflare-init.js');
         publishInitCloudflare(args.slice(2));
         return;
     }
+    if (command === 'publish' && args[0] === 'init' && args[1] === 'vercel') {
+        const { publishInitVercel } = await import('../publish/vercel-init.js');
+        publishInitVercel(args.slice(2));
+        return;
+    }
     if (command === 'publish') {
+        const { publish } = await import('../deploy/cloudflare.js');
         publish(args);
         return;
     }
     if (command === 'deploy') {
+        const { deploy } = await import('../deploy/cloudflare.js');
         deploy(args);
         return;
     }
     if (command === 'dp') {
+        const { deploy } = await import('../deploy/cloudflare.js');
         deploy(args);
         return;
     }
-    throw new Error(`Unknown command: ${command}`);
+    const { viewer } = await import('../site/viewer.js');
+    await viewer([command, ...args]);
 }

package/dist/cli/usage.js

@@ -1,13 +1,19 @@
 export function usage() {
     console.log(`Usage:
-  kennel schema <path>
-  kennel validate <path>
-  kennel doctor <path>
+  kennel [folder] [--host <host>] [--port <port>] [--lan|--tailscale]
+  kennel source list [path] [--config <json-file>] [--json]
+  kennel source describe <id> [path] [--config <json-file>] [--json]
+  kennel source doctor [path] [--config <json-file>] [--json]
+  kennel source query <id> [path] [--config <json-file>] [--limit <n>] [--json]
+  kennel source snapshot [path] [--config <json-file>] [--json]
   kennel dev [path] [--config <json-file>] [--port <port>] [--script <script>] [--dry-run] [-- <args...>]
+  kennel extension install
   kennel mcp generate [path] [--config <json-file>] [--data-only|--function-only]
   kennel publish init cloudflare [path] [--config <json-file>] [--force] [--hostname <hostname>]
+  kennel publish init vercel [path] [--config <json-file>] [--force] [--hostname <hostname>]
   kennel publish [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
   kennel publish cloudflare [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
+  kennel publish vercel [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--skip-test]
   kennel deploy [path] [--config <json-file>] [legacy alias for publish]
   kennel dp [path] [--config <json-file>] [legacy alias for publish]
 `);

package/dist/deploy/cloudflare.js

@@ -4,13 +4,15 @@ import { existsSync } from 'node:fs';
 import { relative } from 'node:path';
 import { readJson } from '../shared/json.js';
 import { localBin } from '../shared/package-manager.js';
+import { projectConfigPath } from '../shared/project-config.js';
 import { commandLine } from '../shared/process.js';
-import { packageJsonPath, publishBuildCommand, publishTestUrl, publishWranglerArgs, publishWranglerCommand, publicationAccess, } from '../publish/config.js';
+import { packageJsonPath, publishBuildCommand, publishTestUrl, publishWranglerArgs, publishWranglerCommand, publicationAccess, publicationConfig, } from '../publish/config.js';
 import { publishInitCloudflare } from '../publish/cloudflare-init.js';
 import { splitPublishArgs } from '../publish/options.js';
 import { withCloudflareEnvironment } from './environment.js';
 import { runAccessHttpTest, runHttpTest } from './smoke-tests.js';
 import { syncTriggerDev } from './trigger-dev.js';
+import { publishVercel } from './vercel.js';
 export function runPublishCommand(root, child, options) {
     console.log(commandLine(child.command, child.args));
     if (options.dryRun)
@@ -84,6 +86,13 @@ export function publish(input) {
     if (input[0] === 'cloudflare' || input[0] === 'cloudflare-workers') {
         return publishCloudflare(input.slice(1));
     }
+    if (input[0] === 'vercel')
+        return publishVercel(input.slice(1));
+    const options = splitPublishArgs(input);
+    const config = readJson(projectConfigPath(options.targetPath, options.configFile));
+    const provider = publicationConfig(config).provider;
+    if (provider === 'vercel')
+        return publishVercel(input);
     return publishCloudflare(input);
 }
 export function deploy(input) {

package/dist/deploy/smoke-tests.d.ts

@@ -1,3 +1,4 @@
 import type { PublishOptions } from '../publish/options.js';
 export declare function runHttpTest(root: string, hostname: string, testEmail: string, options: PublishOptions): void;
+export declare function runStaticHttpTest(root: string, hostname: string, options: PublishOptions): void;
 export declare function runAccessHttpTest(root: string, hostname: string, options: PublishOptions): void;

package/dist/deploy/smoke-tests.js

@@ -47,6 +47,27 @@ export function runHttpTest(root, hostname, testEmail, options) {
         }
     }
 }
+export function runStaticHttpTest(root, hostname, options) {
+    const baseUrl = publishTestUrl(hostname);
+    if (!baseUrl) {
+        console.log('skip test: no hostname configured');
+        return;
+    }
+    if (!commandExists('curl')) {
+        console.log('skip test: curl is not available');
+        return;
+    }
+    const rootTest = {
+        command: 'curl',
+        args: ['-fsS', '-H', 'Cache-Control: no-cache', baseUrl],
+    };
+    console.log(`${commandLine(rootTest.command, rootTest.args)} | returns 2xx`);
+    if (!options.dryRun) {
+        const result = spawnSync(rootTest.command, rootTest.args, { cwd: root, stdio: 'ignore' });
+        if (result.status !== 0)
+            throw new Error(`${baseUrl} did not return a successful response`);
+    }
+}
 export function runAccessHttpTest(root, hostname, options) {
     const baseUrl = publishTestUrl(hostname);
     if (!baseUrl) {

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

@@ -152,6 +152,18 @@ function toolPacks(config) {
         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');
@@ -159,11 +171,13 @@ export function serverConfig(config) {
         ...(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/mcp/function-source.js

@@ -16,7 +16,7 @@ export function mcpFunctionSource(options) {
         ].join(', ')}];\n`
         : '';
     const customToolOption = customToolNames.length || toolModuleNames.length ? ', customTools' : '';
-    return `import { createMcpHttpHandler } from "@raggle-ai/kennel-mcp";
+    return `import { createMcpHttpHandler } from "@raggle-ai/kennel/mcp";
 import data from "./_generated/mcp-data.json";
 ${customToolImports ? `${customToolImports}\n` : ''}${toolModuleImports ? `${toolModuleImports}\n` : ''}
 
@@ -24,8 +24,10 @@ 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;

package/dist/mcp/generate.js

@@ -22,11 +22,11 @@ export async function generateMcp(input) {
         };
         const agentDirectory = agentToolsDirectory(config);
         const agentTools = agentDirectory ? collectAgentTools(root, agentDirectory) : [];
-        const { docs, health, repos } = collectMcpData(root, dataConfig);
+        const { docs, health, records, repos, sources } = 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)`);
+        writeMcpData(target, docs, repos, agentTools, health, records, sources);
+        console.log(`ok ${relative(root, target)} (${docs.length} docs, ${repos.length} repos, ${agentTools.length} agent tools, ${records.length} records, ${sources.length} sources)`);
     }
     if (!options.dataOnly) {
         const target = functionPath(root, config);

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

@@ -1 +1,12 @@
-export declare function writeInstallPage(root: string, config: any): string | undefined;
+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;