@husar.ai/cli 0.2.14 → 0.3.2

package/dist/mcp.js

@@ -1,69 +1,132 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import { z } from 'zod';
 import { ConfigMaker } from 'config-maker';
-import { spawn } from 'node:child_process';
+import { parser } from './functions/parser.js';
+import { generateCms } from './functions/generate.js';
+import path from 'path';
+import { buildClientSchema, printSchema, buildSchema, isObjectType, getNamedType, isNonNullType, isListType, } from 'graphql';
 const server = new McpServer({ name: 'mcp-husar', version: '1.0.0' });
-let config;
-const getWorkspaceRoot = async () => {
-    const envRoot = process.env.WORKSPACE_ROOT;
-    if (envRoot)
-        return envRoot;
-    let cur = process.cwd();
-    for (let i = 0; i < 10; i++) {
-        try {
-            const pkgPath = path.join(cur, 'package.json');
-            const st = await fs.stat(pkgPath);
-            if (st.isFile()) {
-                const txt = await fs.readFile(pkgPath, 'utf8');
-                const pkg = JSON.parse(txt);
-                if (pkg && Object.prototype.hasOwnProperty.call(pkg, 'workspaces'))
-                    return cur;
-            }
+const INTROSPECTION_QUERY = `
+  query IntrospectionQuery {
+    __schema {
+      queryType { name }
+      mutationType { name }
+      subscriptionType { name }
+      types {
+        kind
+        name
+        description
+        fields(includeDeprecated: true) {
+          name
+          description
+          args { name description type { kind name ofType { kind name ofType { kind name } } } defaultValue }
+          type { kind name ofType { kind name ofType { kind name } } }
+          isDeprecated
+          deprecationReason
         }
-        catch {
+        inputFields { name description type { kind name ofType { kind name ofType { kind name } } } defaultValue }
+        interfaces { kind name ofType { kind name ofType { kind name } } }
+        enumValues(includeDeprecated: true) { name description isDeprecated deprecationReason }
+        possibleTypes { kind name ofType { kind name ofType { kind name } } }
+      }
+      directives { name description locations args { name description type { kind name ofType { kind name ofType { kind name } } } defaultValue } }
+    }
+  }
+`;
+function tokenize(s) {
+    return (s || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, ' ')
+        .split(' ')
+        .filter(Boolean);
+}
+function scoreField(taskTokens, fieldName, returnTypeName, argNames) {
+    const nameTokens = tokenize(fieldName).concat(tokenize(returnTypeName)).concat(argNames.flatMap(tokenize));
+    let score = 0;
+    for (const t of taskTokens)
+        if (nameTokens.includes(t))
+            score += 2;
+    for (const t of taskTokens)
+        if (fieldName.includes(t))
+            score += 1;
+    return score;
+}
+function pickFieldsForSelection(type) {
+    const fields = Object.values(type.getFields());
+    const preferred = ['id', '_id', 'slug', 'name', 'title', 'key', 'display', 'createdAt', 'updatedAt'];
+    const names = fields.map((f) => f.name);
+    const out = [];
+    for (const p of preferred)
+        if (names.includes(p))
+            out.push(p);
+    for (const n of names)
+        if (out.length < 6 && !out.includes(n))
+            out.push(n);
+    return out.slice(0, 6);
+}
+function variablesTemplateFromArgs(args) {
+    const tmpl = {};
+    for (const a of args)
+        tmpl[a.name] = null;
+    return tmpl;
+}
+function unwrapNamed(type) {
+    let t = type;
+    let list = false;
+    while (isNonNullType(t) || isListType(t)) {
+        if (isListType(t))
+            list = true;
+        t = t.ofType;
+    }
+    return { named: t, list };
+}
+function suggestQueryFromSDL({ sdl, task, rootType = 'Query' }) {
+    const schema = buildSchema(sdl);
+    const root = schema.getType(rootType);
+    if (!root || !isObjectType(root))
+        throw new Error(`Root type ${rootType} not found or not an object`);
+    const fields = Object.values(root.getFields());
+    const taskTokens = tokenize(task);
+    let best = fields[0];
+    let bestScore = -Infinity;
+    for (const f of fields) {
+        const { named } = unwrapNamed(f.type);
+        const retName = named.name || '';
+        const s = scoreField(taskTokens, f.name, retName, f.args.map((a) => a.name));
+        if (s > bestScore) {
+            best = f;
+            bestScore = s;
         }
-        const parent = path.dirname(cur);
-        if (parent === cur)
-            break;
-        cur = parent;
     }
-    return process.cwd();
-};
-const resolveWorkspacePath = async (p) => {
-    if (path.isAbsolute(p))
-        return p;
-    const root = await getWorkspaceRoot();
-    return path.resolve(root, p);
-};
-const getConfig = async () => {
-    if (config)
-        return config;
-    const root = await getWorkspaceRoot();
-    config = new ConfigMaker('husar', {
+    const argsDecl = best.args
+        .map((a) => `$${a.name}: ${a.type.toString()}`)
+        .join(', ');
+    const argsUse = best.args.map((a) => `${a.name}: $${a.name}`).join(', ');
+    const { named, list } = unwrapNamed(best.type);
+    let selection = '__typename';
+    if (isObjectType(named)) {
+        const sel = pickFieldsForSelection(named);
+        selection = sel.join('\n          ');
+    }
+    const opName = 'GeneratedQuery';
+    const query = `query ${opName}${argsDecl ? `(${argsDecl})` : ''} {
+  ${best.name}${argsUse ? `(${argsUse})` : ''} {
+    ${list ? `nodes { ${selection} }` : selection}
+  }
+}`;
+    const variables = variablesTemplateFromArgs(best.args);
+    const candidates = fields
+        .map((f) => ({ name: f.name, type: getNamedType(f.type)?.name || String(f.type) }))
+        .slice(0, 20);
+    return { query, variables, pickedField: best.name, rootType, candidates };
+}
+const getConfig = async (pathToProject) => {
+    return new ConfigMaker('husar', {
         decoders: {},
-        pathToProject: root,
+        pathToProject,
     });
-    return config;
-};
-const getAuth = async () => {
-    const envHost = process.env.HUSAR_MCP_HOST;
-    const envToken = process.env.HUSAR_MCP_ADMIN_TOKEN;
-    if (envHost && envToken)
-        return { host: envHost, adminToken: envToken };
-    try {
-        const cfg = await getConfig();
-        const { host, adminToken } = cfg.get();
-        if (host && adminToken)
-            return { host, adminToken };
-    }
-    catch {
-    }
-    throw new Error('Missing HUSAR_MCP_HOST and/or HUSAR_MCP_ADMIN_TOKEN. Provide via env or husar.json in workspace root. ' +
-        (await getWorkspaceRoot()));
 };
 const cmsParseFileInputFields = {
     path: z
@@ -79,6 +142,10 @@ const cmsParseFileInputFields = {
         .string()
         .optional()
         .describe('Optional CMS name. Must not contain dashes (-). Prefer lowercase with underscores (e.g., examples_contactform). Defaults to the filename (lowercased).'),
+    workspaceRoot: z
+        .string()
+        .optional()
+        .describe('Target folder for where husar.json is located. Needed when run in monorepo where husar.json is located in child repo'),
 };
 const cmsParseFileInputSchema = z.object(cmsParseFileInputFields);
 const withTimeout = async (promise, ms) => {
@@ -123,35 +190,30 @@ const redirectConsoleToStderr = () => {
         console.dir = original.dir;
     };
 };
-const runCli = async (args, workspaceCwd) => {
-    const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-    return await new Promise((resolve) => {
-        const child = spawn(npxBin, ['-y', '@husar.ai/cli', ...args], {
-            cwd: workspaceCwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env },
-            shell: false,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (d) => (stdout += String(d)));
-        child.stderr.on('data', (d) => (stderr += String(d)));
-        child.on('close', (code) => resolve({ code: code ?? 1, stdout, stderr }));
-    });
-};
 const createCmsParseFileHandler = ({ timeoutMs = 30_000 }) => {
-    return async ({ path: file, type, name: passed }) => {
+    return async ({ path: file, type, name: passed, workspaceRoot }) => {
         const restoreConsole = redirectConsoleToStderr();
         try {
-            await getAuth();
-            const absPath = await resolveWorkspacePath(file);
-            const root = await getWorkspaceRoot();
-            const name = (passed ?? (absPath.replace(/^.*\/(.*?)(\.[^.]+)?$/, '$1') || 'untitled')).toLowerCase();
-            const res = await withTimeout(runCli(['copy', absPath, name, '-t', type ?? 'shape'], root), timeoutMs);
-            if (res.code !== 0) {
-                throw new Error(`CLI exited with code ${res.code}.\nSTDOUT:\n${res.stdout}\nSTDERR:\n${res.stderr}`);
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const inputFile = stripWorkspaceRoot(file, workspaceRoot);
+            const name = (passed ?? (inputFile.replace(/^.*\/(.*?)(\.[^.]+)?$/, '$1') || 'untitled')).toLowerCase();
+            if (!raw.host) {
+                throw new Error('Please implement host in husar.json');
+            }
+            if (!raw.adminToken) {
+                throw new Error('Please implement adminToken in husar.json');
             }
-            return { content: [{ type: 'text', text: res.stdout || 'ok' }] };
+            const result = await withTimeout(parser({
+                inputFile,
+                workspaceRoot,
+                opts: { type: (type ?? 'shape'), name },
+                authentication: {
+                    HUSAR_MCP_HOST: raw.host,
+                    HUSAR_MCP_ADMIN_TOKEN: raw.adminToken,
+                },
+            }), timeoutMs);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -168,28 +230,369 @@ const createCmsParseFileHandler = ({ timeoutMs = 30_000 }) => {
     };
 };
 export const startMcpServer = async () => {
-    server.tool('cms_parse_file', 'Parse a CMS file into a shape or model', cmsParseFileInputFields, createCmsParseFileHandler({ timeoutMs: Number(process.env.MCP_PARSER_TIMEOUT_MS || 30000) }));
     server.tool('husar_copy', 'Copy: parse HTML/JSX and upsert into CMS (model/shape)', cmsParseFileInputFields, createCmsParseFileHandler({ timeoutMs: Number(process.env.MCP_PARSER_TIMEOUT_MS || 30000) }));
     const husarGenerateInput = {
         folderPath: z
             .string()
             .optional()
             .describe('Target folder for cms scaffolding. Relative to workspace root; defaults to ".".'),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe('Target folder for where husar.json is located. Needed when run in monorepo where husar.json is located in child repo'),
     };
     const husarGenerateSchema = z.object(husarGenerateInput);
     server.tool('husar_generate', 'Generate cms structure in the given path', husarGenerateInput, (async (args) => {
         try {
-            const { folderPath } = husarGenerateSchema.parse(args ?? {});
-            const root = await getWorkspaceRoot();
-            await getAuth();
-            const argsList = ['generate'];
-            if (folderPath)
-                argsList.push(folderPath);
-            const res = await runCli(argsList, root);
-            if (res.code !== 0) {
-                throw new Error(`CLI exited with code ${res.code}.\nSTDOUT:\n${res.stdout}\nSTDERR:\n${res.stderr}`);
+            const { folderPath = './src', workspaceRoot } = husarGenerateSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            if (!host) {
+                throw new Error('Missing host. Provide via husar.json (host) or HUSAR_MCP_HOST/HUSAR_HOST env.');
             }
-            return { content: [{ type: 'text', text: res.stdout || 'ok' }] };
+            const base = workspaceRoot ? path.join(workspaceRoot, folderPath) : folderPath;
+            const cmsPath = await generateCms({
+                baseFolder: base,
+                host,
+                hostEnvironmentVariable: raw.hostEnvironmentVariable,
+                authenticationEnvironmentVariable: raw.authenticationEnvironmentVariable,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify({ status: 'ok', folder: cmsPath }, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarGraphQLQueryInput = {
+        query: z.string().min(1).describe('GraphQL query string.'),
+        variables: z
+            .union([z.string(), z.record(z.any())])
+            .optional()
+            .describe('Optional variables as JSON string or object.'),
+        endpointPath: z
+            .string()
+            .optional()
+            .default('api/graphql')
+            .describe('Endpoint path relative to host, defaults to api/graphql'),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe('Location of husar.json if not in current working directory.'),
+    };
+    const husarGraphQLQuerySchema = z.object(husarGraphQLQueryInput);
+    server.tool('husar_graphql_query', 'Run a read-only GraphQL query against the configured Husar host', husarGraphQLQueryInput, (async (args) => {
+        try {
+            const { query, variables, endpointPath, workspaceRoot } = husarGraphQLQuerySchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            const token = raw.adminToken;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            if (!token)
+                throw new Error('Missing adminToken in husar.json');
+            const url = new URL(endpointPath || 'api/graphql', host).toString();
+            const vars = typeof variables === 'string' && variables.trim().length
+                ? JSON.parse(variables)
+                : variables ?? {};
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', husar_token: token },
+                body: JSON.stringify({ query, variables: vars }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify(json, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarGraphQLSchemaInput = {
+        endpointPath: z
+            .string()
+            .optional()
+            .default('api/graphql')
+            .describe('Endpoint path relative to host, defaults to api/graphql'),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe('Location of husar.json if not in current working directory.'),
+    };
+    const husarGraphQLSchemaSchema = z.object(husarGraphQLSchemaInput);
+    server.tool('husar_graphql_schema', 'Fetch GraphQL schema (introspection) from Admin API', husarGraphQLSchemaInput, (async (args) => {
+        try {
+            const { endpointPath, workspaceRoot } = husarGraphQLSchemaSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            const token = raw.adminToken;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            if (!token)
+                throw new Error('Missing adminToken in husar.json');
+            const url = new URL(endpointPath || 'api/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', husar_token: token },
+                body: JSON.stringify({ query: INTROSPECTION_QUERY }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify(json, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    server.tool('husar_graphql_schema_sdl', 'Fetch Admin GraphQL schema and return SDL', husarGraphQLSchemaInput, (async (args) => {
+        try {
+            const { endpointPath, workspaceRoot } = husarGraphQLSchemaSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            const token = raw.adminToken;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            if (!token)
+                throw new Error('Missing adminToken in husar.json');
+            const url = new URL(endpointPath || 'api/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', husar_token: token },
+                body: JSON.stringify({ query: INTROSPECTION_QUERY }),
+            });
+            const json = await res.json();
+            if (!json?.data)
+                throw new Error('No data from introspection');
+            const schema = buildClientSchema(json.data);
+            const sdl = printSchema(schema);
+            return { content: [{ type: 'text', text: sdl }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarContentGraphQLQueryInput = {
+        query: z.string().min(1).describe('GraphQL query string.'),
+        variables: z
+            .union([z.string(), z.record(z.any())])
+            .optional()
+            .describe('Optional variables as JSON string or object.'),
+        endpointPath: z
+            .string()
+            .optional()
+            .default('content/graphql')
+            .describe('Endpoint path relative to host, defaults to content/graphql'),
+        apiKey: z.string().optional().describe('Content API key. If omitted, apiKeyEnv is used.'),
+        apiKeyEnv: z.string().optional().describe('Environment variable name containing the Content API key.'),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe('Location of husar.json if not in current working directory.'),
+    };
+    const husarContentGraphQLQuerySchema = z.object(husarContentGraphQLQueryInput);
+    server.tool('husar_content_graphql_query', 'Run a read-only GraphQL query against the Content API (api-key required)', husarContentGraphQLQueryInput, (async (args) => {
+        try {
+            const { query, variables, endpointPath, apiKey, apiKeyEnv, workspaceRoot } = husarContentGraphQLQuerySchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            const keyFromEnv = apiKeyEnv ? process.env[apiKeyEnv] : undefined;
+            const keyFromConfig = raw.contentApiKey;
+            const usedKey = apiKey || keyFromEnv || keyFromConfig;
+            if (!usedKey)
+                throw new Error('Missing apiKey. Provide apiKey, apiKeyEnv, or set contentApiKey in husar.json');
+            const url = new URL(endpointPath || 'content/graphql', host).toString();
+            const vars = typeof variables === 'string' && variables.trim().length
+                ? JSON.parse(variables)
+                : variables ?? {};
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'api-key': usedKey },
+                body: JSON.stringify({ query, variables: vars }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify(json, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarContentGraphQLSchemaInput = {
+        endpointPath: z
+            .string()
+            .optional()
+            .default('content/graphql')
+            .describe('Endpoint path relative to host, defaults to content/graphql'),
+        apiKey: z.string().optional().describe('Content API key. If omitted, apiKeyEnv is used.'),
+        apiKeyEnv: z.string().optional().describe('Environment variable name containing the Content API key.'),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe('Location of husar.json if not in current working directory.'),
+    };
+    const husarContentGraphQLSchemaSchema = z.object(husarContentGraphQLSchemaInput);
+    server.tool('husar_content_graphql_schema', 'Fetch GraphQL schema (introspection) from Content API', husarContentGraphQLSchemaInput, (async (args) => {
+        try {
+            const { endpointPath, apiKey, apiKeyEnv, workspaceRoot } = husarContentGraphQLSchemaSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            const keyFromEnv = apiKeyEnv ? process.env[apiKeyEnv] : undefined;
+            const keyFromConfig = raw.contentApiKey;
+            const usedKey = apiKey || keyFromEnv || keyFromConfig;
+            if (!usedKey)
+                throw new Error('Missing apiKey. Provide apiKey, apiKeyEnv, or set contentApiKey in husar.json');
+            const url = new URL(endpointPath || 'content/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'api-key': usedKey },
+                body: JSON.stringify({ query: INTROSPECTION_QUERY }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify(json, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    server.tool('husar_content_graphql_schema_sdl', 'Fetch Content GraphQL schema and return SDL', husarContentGraphQLSchemaInput, (async (args) => {
+        try {
+            const { endpointPath, apiKey, apiKeyEnv, workspaceRoot } = husarContentGraphQLSchemaSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            const keyFromEnv = apiKeyEnv ? process.env[apiKeyEnv] : undefined;
+            const keyFromConfig = raw.contentApiKey;
+            const usedKey = apiKey || keyFromEnv || keyFromConfig;
+            if (!usedKey)
+                throw new Error('Missing apiKey. Provide apiKey, apiKeyEnv, or set contentApiKey in husar.json');
+            const url = new URL(endpointPath || 'content/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'api-key': usedKey },
+                body: JSON.stringify({ query: INTROSPECTION_QUERY }),
+            });
+            const json = await res.json();
+            if (!json?.data)
+                throw new Error('No data from introspection');
+            const schema = buildClientSchema(json.data);
+            const sdl = printSchema(schema);
+            return { content: [{ type: 'text', text: sdl }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarSuggestInput = {
+        sdl: z.string().min(1).describe('GraphQL schema SDL'),
+        task: z.string().min(1).describe('Task description, e.g., "list posts by tag"'),
+        rootType: z.string().optional().default('Query'),
+    };
+    const husarSuggestSchema = z.object(husarSuggestInput);
+    server.tool('husar_graphql_suggest_query', 'Suggest a GraphQL query and variables template from SDL + task', husarSuggestInput, (async (args) => {
+        try {
+            const { sdl, task, rootType } = husarSuggestSchema.parse(args ?? {});
+            const suggestion = suggestQueryFromSDL({ sdl, task, rootType });
+            return { content: [{ type: 'text', text: JSON.stringify(suggestion, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarRunSuggestionInput = {
+        sdl: z.string().min(1).describe('GraphQL schema SDL'),
+        task: z.string().min(1).describe('Task to execute'),
+        variables: z.union([z.string(), z.record(z.any())]).optional().describe('Override variables (JSON)'),
+        endpointPath: z.string().optional().default('api/graphql'),
+        workspaceRoot: z.string().optional(),
+    };
+    const husarRunSuggestionSchema = z.object(husarRunSuggestionInput);
+    server.tool('husar_graphql_run_suggestion', 'Generate a query from SDL + task and run it on Admin API', husarRunSuggestionInput, (async (args) => {
+        try {
+            const { sdl, task, variables, endpointPath, workspaceRoot } = husarRunSuggestionSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            const token = raw.adminToken;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            if (!token)
+                throw new Error('Missing adminToken in husar.json');
+            const { query, variables: tmpl } = suggestQueryFromSDL({ sdl, task, rootType: 'Query' });
+            const overrides = typeof variables === 'string' && variables.trim().length ? JSON.parse(variables) : variables ?? {};
+            const merged = { ...tmpl, ...overrides };
+            const url = new URL(endpointPath || 'api/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', husar_token: token },
+                body: JSON.stringify({ query, variables: merged }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify({ query, variables: merged, result: json }, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? `\nStack: ${err.stack}` : '';
+            return { isError: true, content: [{ type: 'text', text: `Error: ${message}${stack}` }] };
+        }
+    }));
+    const husarContentRunSuggestionInput = {
+        sdl: z.string().min(1).describe('GraphQL schema SDL'),
+        task: z.string().min(1).describe('Task to execute'),
+        variables: z.union([z.string(), z.record(z.any())]).optional().describe('Override variables (JSON)'),
+        endpointPath: z.string().optional().default('content/graphql'),
+        apiKey: z.string().optional().describe('Content API key'),
+        apiKeyEnv: z.string().optional().describe('Env var name containing Content API key'),
+        workspaceRoot: z.string().optional(),
+    };
+    const husarContentRunSuggestionSchema = z.object(husarContentRunSuggestionInput);
+    server.tool('husar_content_graphql_run_suggestion', 'Generate a query from SDL + task and run it on Content API', husarContentRunSuggestionInput, (async (args) => {
+        try {
+            const { sdl, task, variables, endpointPath, apiKey, apiKeyEnv, workspaceRoot } = husarContentRunSuggestionSchema.parse(args ?? {});
+            const cfg = await getConfig(workspaceRoot);
+            const raw = cfg.get();
+            const host = raw.host;
+            if (!host)
+                throw new Error('Missing host in husar.json');
+            const keyFromEnv = apiKeyEnv ? process.env[apiKeyEnv] : undefined;
+            const keyFromConfig = raw.contentApiKey;
+            const usedKey = apiKey || keyFromEnv || keyFromConfig;
+            if (!usedKey)
+                throw new Error('Missing apiKey. Provide apiKey/apiKeyEnv or set contentApiKey in husar.json');
+            const { query, variables: tmpl } = suggestQueryFromSDL({ sdl, task, rootType: 'Query' });
+            const overrides = typeof variables === 'string' && variables.trim().length ? JSON.parse(variables) : variables ?? {};
+            const merged = { ...tmpl, ...overrides };
+            const url = new URL(endpointPath || 'content/graphql', host).toString();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'api-key': usedKey },
+                body: JSON.stringify({ query, variables: merged }),
+            });
+            const json = await res.json();
+            return { content: [{ type: 'text', text: JSON.stringify({ query, variables: merged, result: json }, null, 2) }] };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -225,4 +628,19 @@ export const startMcpServer = async () => {
 if (import.meta.url === `file://${process.argv[1]}`) {
     void startMcpServer();
 }
+export function stripWorkspaceRoot(filePath, workspaceRoot) {
+    if (!workspaceRoot)
+        return filePath;
+    const rootAbs = path.resolve(workspaceRoot);
+    const fileAbs = path.resolve(filePath);
+    const isWin = path.sep === '\\';
+    const rootCmp = isWin ? rootAbs.toLowerCase() : rootAbs;
+    const fileCmp = isWin ? fileAbs.toLowerCase() : fileAbs;
+    if (fileCmp === rootCmp)
+        return '';
+    if (fileCmp.startsWith(rootCmp + path.sep)) {
+        return path.relative(rootAbs, fileAbs);
+    }
+    return filePath;
+}
 //# sourceMappingURL=mcp.js.map