@waica/cli 0.3.0

package/dist/mcp/package-resolver.js

@@ -0,0 +1,240 @@
+import { access, readFile, realpath } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { workspacePackageRoot } from './workspace-runtime.js';
+/** A declared package that is absent from both the project and MCP bundle. */
+export class PackageUnavailableError extends Error {
+    packageName;
+    constructor(packageName) {
+        super(`Package ${packageName} is not installed and is not part of the MCP bundle.`);
+        this.packageName = packageName;
+        this.name = 'PackageUnavailableError';
+    }
+}
+const BUNDLED_SPECIFIERS = new Set([
+    '@waica/engine',
+    '@waica/behaviors',
+    '@waica/archetype-platformer/manifest',
+]);
+const requireBundled = createRequire(import.meta.url);
+const BUILT_ENTRY_BY_SPECIFIER = {
+    '@waica/engine': 'dist/index.js',
+    '@waica/behaviors': 'dist/index.js',
+    '@waica/archetype-platformer/manifest': 'dist/manifest.js',
+};
+function specifierFor(packageName, subpath) {
+    if (!subpath || subpath === '.')
+        return packageName;
+    return `${packageName}/${subpath.replace(/^\.\//, '')}`;
+}
+async function projectPackageJsonUsable(projectPath) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(projectPath, 'package.json'), 'utf8'));
+        return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return true;
+        if (error instanceof SyntaxError)
+            return false;
+        throw error;
+    }
+}
+async function packageVersion(packageRoot) {
+    const manifest = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+    if (typeof manifest.version !== 'string') {
+        throw new Error(`package at ${packageRoot} has no string version`);
+    }
+    return manifest.version;
+}
+async function packageRootFromEntry(entry, packageName) {
+    let current = path.dirname(entry);
+    while (true) {
+        try {
+            const manifest = JSON.parse(await readFile(path.join(current, 'package.json'), 'utf8'));
+            if (manifest.name === packageName)
+                return current;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            throw new Error(`could not locate package root for ${packageName}`);
+        current = parent;
+    }
+}
+async function bundledPackageRoot(packageName, specifier) {
+    // In a built checkout the workspace copy is the bundle: the CLI's vendored
+    // directory is a copy of it, and preferring the original keeps a
+    // workspace-linked project recognisable as project-owned.
+    const workspaceRoot = await workspacePackageRoot(packageName);
+    if (workspaceRoot !== undefined)
+        return workspaceRoot;
+    return packageRootFromEntry(requireBundled.resolve(specifier), packageName);
+}
+async function installedPackageRoot(projectPath, projectRequire, packageName, specifier) {
+    // Follow Node's ancestor node_modules search so hoisted installs count. A
+    // physical candidate distinguishes an absent package from a present but
+    // unloadable one; a successful resolution must point back to that candidate.
+    for (let current = projectPath;; current = path.dirname(current)) {
+        const candidate = path.join(current, 'node_modules', ...packageName.split('/'));
+        if (await exists(path.join(candidate, 'package.json'))) {
+            let entry;
+            try {
+                entry = projectRequire.resolve(specifier);
+            }
+            catch {
+                return candidate;
+            }
+            const resolvedRoot = await packageRootFromEntry(entry, packageName);
+            if (!(await samePackage(candidate, resolvedRoot))) {
+                throw new Error(`${specifier} resolved outside its installed package root ${candidate}: ${resolvedRoot}`);
+            }
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+    }
+}
+/**
+ * A built checkout and a published package both carry loadable dist files.
+ * Vitest runs buildless, so its literal-import fallback still consumes the
+ * workspace source through Vite without changing production resolution.
+ */
+async function loadBundledModule(specifier, packageRoot) {
+    const builtRelative = BUILT_ENTRY_BY_SPECIFIER[specifier];
+    if (builtRelative) {
+        const builtEntry = path.join(packageRoot, builtRelative);
+        if (await exists(builtEntry))
+            return import(pathToFileURL(builtEntry).href);
+    }
+    switch (specifier) {
+        case '@waica/engine':
+            return import('@waica/engine');
+        case '@waica/behaviors':
+            return import('@waica/behaviors');
+        case '@waica/archetype-platformer/manifest':
+            return import('@waica/archetype-platformer/manifest');
+        default:
+            throw new PackageUnavailableError(specifier);
+    }
+}
+function causeText(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const code = error.code;
+    return `${code ? `${code}: ` : ''}${error.message}`;
+}
+async function samePackage(a, b) {
+    try {
+        return (await realpath(a)) === (await realpath(b));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves runtime answers from a game project's real Node installation.
+ * Resolution is anchored with createRequire so hoisted installs count as
+ * project-owned. A present package that Node cannot load is surfaced and is
+ * never silently replaced with another version.
+ */
+export class PackageResolver {
+    projectPath;
+    projectRequire;
+    projectManifestUsable;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        if (projectPath) {
+            this.projectRequire = createRequire(path.join(projectPath, 'package.json'));
+            this.projectManifestUsable = projectPackageJsonUsable(projectPath);
+        }
+    }
+    async load(packageName, subpath) {
+        const specifier = specifierFor(packageName, subpath);
+        const projectRoot = this.projectPath &&
+            this.projectRequire &&
+            (await this.projectManifestUsable)
+            ? await installedPackageRoot(this.projectPath, this.projectRequire, packageName, specifier)
+            : undefined;
+        if (projectRoot && this.projectRequire) {
+            let version = '(unknown version)';
+            try {
+                version = await packageVersion(projectRoot);
+                let loaded;
+                try {
+                    loaded = this.projectRequire(specifier);
+                }
+                catch (error) {
+                    // The repository's pre-publish workspace links intentionally export
+                    // TS source to bundlers. Once the checkout is built, the CLI's
+                    // workspace runtime hook makes the same physical package loadable
+                    // from dist without weakening errors for arbitrary broken installs.
+                    const bundledRoot = BUNDLED_SPECIFIERS.has(specifier)
+                        ? await bundledPackageRoot(packageName, specifier)
+                        : undefined;
+                    if (!bundledRoot || !(await samePackage(projectRoot, bundledRoot)))
+                        throw error;
+                    loaded = (await loadBundledModule(specifier, bundledRoot));
+                }
+                return {
+                    module: loaded,
+                    packageRoot: projectRoot,
+                    provenance: { package: packageName, version, source: 'project' },
+                };
+            }
+            catch (error) {
+                throw new Error(`Cannot load ${packageName} ${version} from the project: ${causeText(error)}`, { cause: error });
+            }
+        }
+        if (!BUNDLED_SPECIFIERS.has(specifier))
+            throw new PackageUnavailableError(packageName);
+        try {
+            const packageRoot = await bundledPackageRoot(packageName, specifier);
+            const version = await packageVersion(packageRoot);
+            return {
+                module: (await loadBundledModule(specifier, packageRoot)),
+                packageRoot,
+                provenance: { package: packageName, version, source: 'bundled' },
+            };
+        }
+        catch (error) {
+            throw new Error(`Cannot load bundled ${packageName}: ${causeText(error)}`, { cause: error });
+        }
+    }
+}
+async function exists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Stable, de-duplicated rows in first-resolution order. */
+export function provenanceRows(loads) {
+    const rows = new Map();
+    for (const loaded of loads) {
+        if (!rows.has(loaded.provenance.package)) {
+            rows.set(loaded.provenance.package, loaded.provenance);
+        }
+    }
+    return [...rows.values()];
+}
+/** Makes per-package fallback visible whenever an answer mixes sources. */
+export function mixedSourceWarnings(rows) {
+    if (new Set(rows.map((row) => row.source)).size < 2)
+        return [];
+    const describe = (source) => {
+        const names = rows.filter((row) => row.source === source).map((row) => row.package);
+        return `${names.join(', ')} from ${source === 'project' ? 'the project' : 'the MCP bundle'}`;
+    };
+    return [`Mixed @waica package sources: ${describe('project')}; ${describe('bundled')}.`];
+}

package/dist/mcp/project-path.js

@@ -0,0 +1,86 @@
+import { access, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+export class WaicaToolError extends Error {
+    body;
+    constructor(body) {
+        super(body.message);
+        this.body = body;
+        this.name = 'WaicaToolError';
+    }
+}
+export const ABSOLUTE_PATH_MESSAGE = "project_path must be absolute because a stdio server's working directory belongs to the agent host, not the game project.";
+export function assertAbsoluteProjectPath(projectPath) {
+    if (!path.isAbsolute(projectPath)) {
+        throw new WaicaToolError({
+            code: 'absolute-project-path-required',
+            message: ABSOLUTE_PATH_MESSAGE,
+            projectPath,
+        });
+    }
+}
+async function exists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Enforces the common file-project boundary used by every non-create tool. */
+export async function requireWaicaProject(projectPath) {
+    assertAbsoluteProjectPath(projectPath);
+    let info;
+    try {
+        info = await stat(projectPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw cannotOperate(projectPath, 'missing-path', `Project path does not exist: ${projectPath}`);
+        }
+        throw error;
+    }
+    if (!info.isDirectory()) {
+        throw cannotOperate(projectPath, 'not-directory', `Project path is not a directory: ${projectPath}`);
+    }
+    const gameMarker = await exists(path.join(projectPath, 'src/game.json'));
+    const sceneMarker = await exists(path.join(projectPath, 'src/scenes/main.scene.json'));
+    if (!gameMarker && !sceneMarker) {
+        throw cannotOperate(projectPath, 'not-waica-project', 'Not a Waica project: expected src/game.json or src/scenes/main.scene.json.');
+    }
+    const notes = [];
+    if (!gameMarker)
+        notes.push('Project marker src/game.json is missing; main.scene.json was accepted.');
+    if (!sceneMarker) {
+        notes.push('Project marker src/scenes/main.scene.json is missing; src/game.json was accepted.');
+    }
+    return { notes };
+}
+export function cannotOperate(projectPath, reason, message) {
+    return new WaicaToolError({
+        code: 'cannot-operate',
+        message,
+        projectPath,
+        reason,
+    });
+}
+export async function directFiles(directory, suffix) {
+    try {
+        return (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && (!suffix || entry.name.endsWith(suffix)))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+export function assertSafeSlug(value, label) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value)) {
+        throw new Error(`${label} must use letters, numbers, hyphens or underscores and cannot contain a path.`);
+    }
+}

package/dist/mcp/scaffolds.js

@@ -0,0 +1,153 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { assertSafeSlug } from './project-path.js';
+function nameWords(name) {
+    return name
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean);
+}
+export function componentClassName(name) {
+    const words = nameWords(name);
+    const value = words.map((word) => word[0]?.toUpperCase() + word.slice(1)).join('');
+    if (!/^[A-Za-z][A-Za-z0-9]*$/.test(value)) {
+        throw new Error('Component names must start with a letter and use letters or numbers.');
+    }
+    if (value === 'Component') {
+        throw new Error('"Component" is the engine base class — pick another name.');
+    }
+    return value;
+}
+function componentFilePath(name) {
+    const words = nameWords(name);
+    componentClassName(name);
+    return `src/components/${words.map((word) => word.toLowerCase()).join('-')}.ts`;
+}
+function componentTemplate(name) {
+    const Class = componentClassName(name);
+    return `import { Component } from '@waica/engine'
+
+// Project-owned behavior — loaded by the shipped game and editor Play.
+export class ${Class} extends Component {
+  static override componentName = '${Class}'
+  static override params = {
+    speed: { label: 'Speed', min: 0, max: 30, step: 0.5 },
+  }
+
+  speed = 5
+
+  override onUpdate(dt: number): void {
+    // Add this component's per-frame behavior here.
+    void dt
+  }
+}
+`;
+}
+function roleTemplate(role) {
+    return `import { defineRole } from '@waica/engine'
+
+// The "${role}" role — generated by waica.
+// A role is a character's whole behavior package: a plain-language
+// description for the editor, the driver component its states move,
+// the starter state graph, and the state code itself.
+defineRole('${role}', {
+  description: 'Describe what a ${role} does — shown when picking roles.',
+  // driver: 'PlatformerMotor', // uncomment if the states move a driver component
+  graph: {
+    initial: 'idle',
+    states: { idle: { transitions: [] } },
+  },
+  states: {
+    idle: {
+      onUpdate({ entity, game, fsm }, dt) {
+        // Runs every frame while a "${role}" is in its "idle" state.
+      },
+    },
+  },
+})
+`;
+}
+function stateTemplate(role, state) {
+    if (role === 'player') {
+        return `import { defineStates } from '@waica/engine'
+import { PlatformerMotor } from '@waica/behaviors'
+
+// Code for the "${state}" state — generated by waica.
+// When it starts, when it ends and which clip it plays live in the
+// prefab's State Machine data. While in it, the body keeps the role's
+// stock update (running, gravity, collisions, land/fall signals), so
+// this file only says what makes "${state}" special.
+defineStates('${role}', {
+  ${state}: {
+    onEnter({ entity }) {
+      const motor = entity.get(PlatformerMotor)
+      if (!motor) return
+      // One burst in the facing direction — replace with your state's idea.
+      motor.vx = motor.facing * 30
+    },
+  },
+})
+`;
+    }
+    return `import { defineStates } from '@waica/engine'
+
+// Code for the "${state}" state — generated by waica.
+// When it starts and when it ends live in the prefab's State Machine
+// data; this file is only the behavior. Hooks receive { entity, game, fsm }.
+defineStates('${role}', {
+  ${state}: {
+    onEnter({ entity }) {
+      console.log(\`\${entity.name} entered "${state}"\`)
+    },
+  },
+})
+`;
+}
+const UI_TEMPLATE = `<style>
+  .my-ui {
+    position: absolute;
+    top: 12px;
+    left: 12px;
+    font: 600 20px system-ui, sans-serif;
+    color: #fff;
+  }
+</style>
+<div class="my-ui">✨ {{points}}</div>
+`;
+async function writeOnce(projectPath, relative, contents) {
+    const target = path.join(projectPath, relative);
+    try {
+        await access(target);
+        return { path: relative, created: false, reason: 'exists' };
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, contents);
+    return { path: relative, created: true };
+}
+export async function scaffoldComponent(projectPath, name) {
+    const className = componentClassName(name);
+    return { ...(await writeOnce(projectPath, componentFilePath(name), componentTemplate(name))), className };
+}
+export async function scaffoldRole(projectPath, role) {
+    assertSafeSlug(role, 'role');
+    return writeOnce(projectPath, `src/roles/${role}.ts`, roleTemplate(role));
+}
+export async function scaffoldState(projectPath, role, state) {
+    assertSafeSlug(role, 'role');
+    assertSafeSlug(state, 'state');
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(state)) {
+        throw new Error('state must be a valid TypeScript identifier because the scaffold uses it as an object key.');
+    }
+    // Role-agnostic by contract: the editor and shipped runtime both glob the
+    // flat src/states/*.ts convention, and the file self-registers its role.
+    return writeOnce(projectPath, `src/states/${state}.ts`, stateTemplate(role, state));
+}
+export async function scaffoldUi(projectPath, name) {
+    assertSafeSlug(name, 'name');
+    return writeOnce(projectPath, `src/ui/${name}.html`, UI_TEMPLATE);
+}

package/dist/mcp/server.js

@@ -0,0 +1,217 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { createProject } from './create-project.js';
+import { describeArchetype, listComponents, projectSummary, } from './introspection.js';
+import { ABSOLUTE_PATH_MESSAGE, WaicaToolError, assertAbsoluteProjectPath, requireWaicaProject, } from './project-path.js';
+import { scaffoldComponent, scaffoldRole, scaffoldState, scaffoldUi, } from './scaffolds.js';
+import { validateProject } from './validation.js';
+const PROJECT_PATH = {
+    type: 'string',
+    description: 'Absolute path to the user game project.',
+};
+function schema(properties, required = []) {
+    return {
+        type: 'object',
+        properties: { project_path: PROJECT_PATH, ...properties },
+        required: ['project_path', ...required],
+        additionalProperties: false,
+    };
+}
+export const TOOLS = [
+    {
+        name: 'create_project',
+        description: 'Create a blank or playable Waica project in a new or empty directory.',
+        inputSchema: schema({
+            start: {
+                type: 'string',
+                enum: ['demo', 'blank'],
+                default: 'demo',
+                description: 'demo includes archetype content; blank creates only the chassis.',
+            },
+        }),
+        annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    },
+    {
+        name: 'list_components',
+        description: 'List installed archetype component metadata and textual project-owned code paths.',
+        inputSchema: schema({}),
+        annotations: { openWorldHint: false },
+    },
+    {
+        name: 'describe_archetype',
+        description: 'Describe the active or requested installed archetype manifest.',
+        inputSchema: schema({
+            archetype: {
+                type: 'string',
+                description: 'Optional archetype manifest id; defaults to src/game.json.',
+            },
+        }),
+        annotations: { openWorldHint: false },
+    },
+    {
+        name: 'project_summary',
+        description: 'Summarize scenes, prefabs, code, UI, stats and controls from project files.',
+        inputSchema: schema({}),
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    },
+    {
+        name: 'validate_project',
+        description: 'Validate every project scene, prefab and configuration file with machine findings.',
+        inputSchema: schema({}),
+        annotations: { openWorldHint: false },
+    },
+    {
+        name: 'scaffold_component',
+        description: 'Create the editor-compatible starter for a project-owned component.',
+        inputSchema: schema({ name: { type: 'string', minLength: 1 } }, ['name']),
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    {
+        name: 'scaffold_role',
+        description: 'Create the editor-compatible starter for a custom character role.',
+        inputSchema: schema({ role: { type: 'string', minLength: 1 } }, ['role']),
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    {
+        name: 'scaffold_state',
+        description: 'Create the editor-compatible state-code starter for a role and state.',
+        inputSchema: schema({
+            role: { type: 'string', minLength: 1 },
+            state: {
+                type: 'string',
+                minLength: 1,
+                pattern: '^[A-Za-z][A-Za-z0-9_]*$',
+                description: 'TypeScript identifier used as the generated state object key.',
+            },
+        }, ['role', 'state']),
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    {
+        name: 'scaffold_ui',
+        description: 'Create the editor-compatible starter HTML for a UI piece.',
+        inputSchema: schema({ name: { type: 'string', minLength: 1 } }, ['name']),
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+];
+function requiredString(args, name, projectPath = '') {
+    const value = args[name];
+    if (typeof value === 'string' && value.length > 0)
+        return value;
+    throw new WaicaToolError({
+        code: 'invalid-input',
+        message: `${name} must be a non-empty string.`,
+        projectPath,
+    });
+}
+async function execute(name, args) {
+    const projectPath = requiredString(args, 'project_path');
+    // Keep this at the dispatch boundary so every tool has byte-identical
+    // stdio-cwd semantics, including create_project.
+    assertAbsoluteProjectPath(projectPath);
+    switch (name) {
+        case 'create_project': {
+            const start = args.start === undefined ? 'demo' : requiredString(args, 'start', projectPath);
+            if (start !== 'demo' && start !== 'blank') {
+                throw new WaicaToolError({
+                    code: 'invalid-input',
+                    message: 'start must be "demo" or "blank".',
+                    projectPath,
+                });
+            }
+            return { ...(await createProject(projectPath, start)) };
+        }
+        case 'list_components':
+            return listComponents(projectPath);
+        case 'describe_archetype':
+            return describeArchetype(projectPath, args.archetype === undefined ? undefined : requiredString(args, 'archetype', projectPath));
+        case 'project_summary':
+            return projectSummary(projectPath);
+        case 'validate_project':
+            return validateProject(projectPath);
+        case 'scaffold_component': {
+            const check = await requireWaicaProject(projectPath);
+            return {
+                ...(await scaffoldComponent(projectPath, requiredString(args, 'name', projectPath))),
+                notes: check.notes,
+                provenance: [],
+                warnings: [],
+            };
+        }
+        case 'scaffold_role': {
+            const check = await requireWaicaProject(projectPath);
+            return {
+                ...(await scaffoldRole(projectPath, requiredString(args, 'role', projectPath))),
+                notes: check.notes,
+                provenance: [],
+                warnings: [],
+            };
+        }
+        case 'scaffold_state': {
+            const check = await requireWaicaProject(projectPath);
+            return {
+                ...(await scaffoldState(projectPath, requiredString(args, 'role', projectPath), requiredString(args, 'state', projectPath))),
+                notes: check.notes,
+                provenance: [],
+                warnings: [],
+            };
+        }
+        case 'scaffold_ui': {
+            const check = await requireWaicaProject(projectPath);
+            return {
+                ...(await scaffoldUi(projectPath, requiredString(args, 'name', projectPath))),
+                notes: check.notes,
+                provenance: [],
+                warnings: [],
+            };
+        }
+        default:
+            throw new WaicaToolError({
+                code: 'unknown-tool',
+                message: `Unknown tool "${name}".`,
+                projectPath,
+            });
+    }
+}
+function jsonSafe(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function result(payload, isError = false) {
+    const safe = jsonSafe(payload);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(safe, null, 2) }],
+        structuredContent: safe,
+        ...(isError ? { isError: true } : {}),
+    };
+}
+function errorResult(error, args) {
+    const projectPath = typeof args.project_path === 'string' ? args.project_path : '';
+    if (error instanceof WaicaToolError) {
+        return result({ error: error.body, provenance: [] }, true);
+    }
+    return result({
+        error: {
+            code: 'tool-error',
+            message: error instanceof Error ? error.message : String(error),
+            projectPath,
+        },
+        provenance: [],
+    }, true);
+}
+export function createWaicaMcpServer() {
+    const server = new Server({ name: '@waica/mcp', version: '0.1.0' }, {
+        capabilities: { tools: {} },
+        instructions: 'Operate on user Waica projects through absolute project_path values. Keep editing JSON and TypeScript with the host file tools.',
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const args = (request.params.arguments ?? {});
+        try {
+            return result(await execute(request.params.name, args));
+        }
+        catch (error) {
+            return errorResult(error, args);
+        }
+    });
+    return server;
+}
+export { ABSOLUTE_PATH_MESSAGE };