@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/resources/schemas.js

@@ -0,0 +1,40 @@
+import { fileURLToPath } from 'node:url';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+const schemasDirectory = join(dirname(fileURLToPath(import.meta.url)), 'schemas');
+function listSchemaFiles() {
+    try {
+        return readdirSync(schemasDirectory).filter(file => file.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+}
+export function registerSchemaResources(server) {
+    const schemaFiles = listSchemaFiles();
+    server.registerResource('schema-index', 'ngapps://schemas/index', {
+        title: 'Şema dizini',
+        description: 'Kullanılabilir API gövde şemalarının listesi; npm run generate-schemas ile güncellenir.',
+        mimeType: 'application/json'
+    }, async (uri) => ({
+        contents: [{
+                uri: uri.href,
+                mimeType: 'application/json',
+                text: JSON.stringify({ schemas: schemaFiles.map(file => `ngapps://schemas/${file.replace(/\.json$/, '')}`) })
+            }]
+    }));
+    for (const file of schemaFiles) {
+        const schemaName = file.replace(/\.json$/, '');
+        server.registerResource(`schema-${schemaName}`, `ngapps://schemas/${schemaName}`, {
+            title: `${schemaName} şeması`,
+            description: `${schemaName} API gövdesinin JSON şeması (swagger'dan üretildi)`,
+            mimeType: 'application/json'
+        }, async (uri) => ({
+            contents: [{
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: readFileSync(join(schemasDirectory, file), 'utf8')
+                }]
+        }));
+    }
+}

package/dist/server.js

@@ -0,0 +1,63 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerMicroserviceTools } from './tools/microservices.js';
+import { registerApplicationTools } from './tools/applications.js';
+import { registerDeploymentTools } from './tools/deployments.js';
+import { registerDatasourceTools } from './tools/datasources.js';
+import { registerAutomationTools } from './tools/automations.js';
+import { registerOrganizationTools } from './tools/organizations.js';
+import { registerComponentTools } from './tools/components.js';
+import { registerPlatformTools } from './tools/platformInfo.js';
+import { registerTemplateTools } from './tools/templates.js';
+import { registerWorkflowTools } from './tools/workflows.js';
+import { registerLayoutTools } from './tools/layouts.js';
+import { registerAccessTools } from './tools/access.js';
+import { registerFlowTools } from './tools/flows.js';
+import { registerKnowledgeResources } from './resources/knowledge.js';
+import { registerSchemaResources } from './resources/schemas.js';
+import { instrumentServer } from './observability/trace.js';
+import { registerProjectTools } from './tools/projects.js';
+import { registerEntityTools } from './tools/entities.js';
+import { registerDependencyTools } from './tools/dependencies.js';
+import { registerVariableTools } from './tools/variables.js';
+import { registerFolderTools } from './tools/folders.js';
+import { registerQueryTools } from './tools/queries.js';
+import { registerViewTools } from './tools/views.js';
+import { registerPageTools } from './tools/pages.js';
+import { registerFileTools } from './tools/files.js';
+import { registerRowTools } from './tools/rows.js';
+import { registerDtoTools } from './tools/dtos.js';
+const moduleRegistrations = {
+    platform: registerPlatformTools,
+    project: registerProjectTools,
+    application: registerApplicationTools,
+    datasource: registerDatasourceTools,
+    entity: registerEntityTools,
+    row: registerRowTools,
+    microservice: registerMicroserviceTools,
+    query: registerQueryTools,
+    workflow: registerWorkflowTools,
+    automation: registerAutomationTools,
+    dto: registerDtoTools,
+    view: registerViewTools,
+    page: registerPageTools,
+    component: registerComponentTools,
+    flow: registerFlowTools,
+    layout: registerLayoutTools,
+    variable: registerVariableTools,
+    folder: registerFolderTools,
+    file: registerFileTools,
+    access: registerAccessTools,
+    template: registerTemplateTools,
+    organization: registerOrganizationTools,
+    dependency: registerDependencyTools,
+    deployment: registerDeploymentTools
+};
+export function createGatewayServer(platform) {
+    const server = instrumentServer(new McpServer({ name: 'ngapps', version: '0.1.0' }), platform.config);
+    for (const moduleName of platform.config.modules) {
+        moduleRegistrations[moduleName](server, platform);
+    }
+    registerSchemaResources(server);
+    registerKnowledgeResources(server);
+    return server;
+}

package/dist/tools/access.js

@@ -0,0 +1,27 @@
+import { projectParam, environmentParam, pagingParams, readOnly } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerAccessTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('role_list', {
+        title: 'Rolleri listele',
+        description: "Projenin rollerini listeler. page_create/page_update'in roleIds parametresi bu id'lerdir — rol id'sini tahmin etmeyin, buradan okuyun.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment }) => {
+        const payload = await platform.tenant('GET', project, '/roles', { environment });
+        return { roles: (payload?.data ?? []).map(role => ({ id: role.id, name: role.name, isSuperAdmin: role.isSuperAdmin })) };
+    }));
+    server.registerTool('user_list', {
+        title: 'Kullanıcıları listele',
+        description: 'Projenin kullanıcılarını rolleriyle listeler (test kullanıcısı seçmek, satır sahipliği doğrulamak için).',
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/users', { environment, query })));
+    server.registerTool('org_role_list', {
+        title: 'Organizasyon rollerini listele',
+        description: 'Organization.API tarafındaki rolleri listeler (platform yönetimi); proje içi yetkilendirme için role_list kullanın.',
+        inputSchema: {},
+        annotations: readOnly
+    }, handle(config, () => platform.org('GET', '/roles')));
+}

package/dist/tools/applications.js

@@ -0,0 +1,59 @@
+import { guid, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerApplicationTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('application_list', {
+        title: 'Application listele',
+        description: 'Organizasyondaki application\'ları listeler; projectId ile daraltın.',
+        inputSchema: {
+            projectId: guid.optional(),
+            searchTerm: z.string().optional(),
+            type: z.string().optional().describe('ApplicationType filtresi'),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, args => platform.org('GET', '/applications', { query: args })));
+    server.registerTool('application_get', {
+        title: 'Application getir',
+        description: 'Tek application\'ı id ile getirir.',
+        inputSchema: { id: guid },
+        annotations: readOnly
+    }, handle(config, args => platform.org('GET', `/applications/${args.id}`)));
+    server.registerTool('application_create', {
+        title: 'Application oluştur',
+        description: 'Projeye yeni application ekler.',
+        inputSchema: {
+            projectId: guid,
+            slug: z.string().min(1),
+            name: z.string().min(1),
+            color: z.string().optional(),
+            dns: z.string().optional(),
+            type: z.string().optional().describe('ApplicationType; varsayılan Web'),
+            properties: z.record(z.unknown()).optional(),
+            notFoundPageId: guid.optional()
+        },
+        annotations: writes
+    }, handle(config, ({ projectId, ...body }) => platform.org('POST', `/applications/${projectId}`, { body })));
+    server.registerTool('application_update', {
+        title: 'Application güncelle',
+        description: 'Application bilgilerini günceller; homepageId zorunludur (mevcut değeri application_get ile alın).',
+        inputSchema: {
+            id: guid,
+            slug: z.string().min(1),
+            name: z.string().min(1),
+            homepageId: guid,
+            color: z.string().optional(),
+            dns: z.string().optional(),
+            properties: z.record(z.unknown()).optional(),
+            notFoundPageId: guid.optional()
+        },
+        annotations: updates
+    }, handle(config, ({ id, ...body }) => platform.org('PUT', `/applications/${id}`, { body })));
+    server.registerTool('application_delete', {
+        title: 'Application sil',
+        description: 'Application\'ı kalıcı olarak siler.',
+        inputSchema: { id: guid },
+        annotations: destructive
+    }, handle(config, args => platform.org('DELETE', `/applications/${args.id}`)));
+}

package/dist/tools/automations.js

@@ -0,0 +1,103 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { normalizeWorkflowDefinition, withNormalization } from '../knowledge/normalize.js';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { policyRules } from '../knowledge/rules.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const policyOverrideParam = z.boolean().optional()
+    .describe('true: politika block bulgularını warn\'a indirir (bilinçli istisna; yanıtta işaretlenir)');
+export function registerAutomationTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('automation_list', {
+        title: 'Automation listele',
+        description: 'Entity\'ye bağlı automation\'ları listeler.',
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, ...query }) => platform.tenant('GET', project, `/entities/${entityId}/automation/list`, { environment, query })));
+    server.registerTool('automation_get', {
+        title: 'Automation getir',
+        description: 'Tek automation\'ı step ağacıyla getirir.',
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, id }) => platform.tenant('GET', project, `/entities/${entityId}/automation/${id}`, { environment })));
+    server.registerTool('automation_create', {
+        title: 'Automation oluştur',
+        description: "Entity'ye automation bağlar. definition = CreateWorkflowCommand gövdesi ('automation' nesnesi içermeli; entityId route'tan set edilir). İlk kullanımdan önce platform_guide('workflow') okuyun; gövde politika kontrolünden geçer.",
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, entityId, definition, policyOverride }) => {
+        const normalized = normalizeWorkflowDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'create', workflowKind: 'automation' }, policyOverride));
+        const payload = await platform.tenant('POST', project, `/entities/${entityId}/automation`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+    server.registerTool('automation_update', {
+        title: 'Automation güncelle',
+        description: "Automation tanımını günceller. definition = UpdateWorkflowCommand gövdesi ('automation' nesnesi içermeli); gövde politika kontrolünden geçer.",
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, entityId, id, definition, policyOverride }) => {
+        const normalized = normalizeWorkflowDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'update', workflowKind: 'automation' }, policyOverride));
+        const payload = await platform.tenant('PUT', project, `/entities/${entityId}/automation/${id}`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+    server.registerTool('automation_delete', {
+        title: 'Automation sil',
+        description: 'Automation\'ı siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, entityId, id }) => platform.tenant('DELETE', project, `/entities/${entityId}/automation/${id}`, { environment })));
+    server.registerTool('automation_reorder', {
+        title: 'Automation sırasını değiştir',
+        description: "Entity'nin automation'larının çalışma sırasını toplu günceller; aynı operasyona bağlı birden çok automation'da sıra davranışı belirler.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            automations: z.array(z.object({ id: guid, order: z.number().int().min(0) })).min(1)
+                .describe('Tüm automation\'lar için (id, order) çiftleri; listeyi automation_list ile kurun')
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, entityId, automations }) => platform.tenant('PUT', project, `/entities/${entityId}/automation/orders`, { environment, body: { automations } })));
+    server.registerTool('automation_trigger', {
+        title: 'Automation tetikle',
+        description: 'Automation\'ı elle tetikler. Fire-and-forget çalışır: sonuç bu yanıtta dönmez, automation_histories ile izleyin.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            id: guid,
+            operation: z.string().optional(),
+            recordIds: z.array(z.union([z.string(), z.number()])).optional().describe('Tetiklenecek satır id\'leri')
+        },
+        annotations: writes
+    }, handle(config, ({ project, environment, entityId, id, operation, recordIds }) => platform.tenant('POST', project, `/entities/${entityId}/automation/${id}/trigger`, {
+        environment,
+        body: { operation, recordIds: recordIds ?? [] }
+    })));
+    server.registerTool('automation_histories', {
+        title: 'Automation geçmişi',
+        description: 'Automation çalıştırma geçmişini listeler; automation_trigger sonrası sonucu buradan doğrulayın.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            id: guid,
+            status: z.string().optional().describe('EventStatus filtresi'),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, id, ...query }) => platform.tenant('GET', project, `/entities/${entityId}/automation/${id}/histories`, { environment, query })));
+    server.registerTool('automation_preview', {
+        title: 'Automation önizle',
+        description: 'Kaydedilmemiş automation tanımını çalıştırır; kaydetmeden önce preview ile doğrulayın. definition = PreviewWorkflowCommand gövdesi.',
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, entityId, definition, policyOverride }) => {
+        const normalized = normalizeWorkflowDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'preview', workflowKind: 'automation' }, policyOverride));
+        const payload = await platform.tenant('POST', project, `/entities/${entityId}/automation/preview`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+}

package/dist/tools/common.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const guid = z.string().uuid();
+export const projectParam = z.string().min(1).optional()
+    .describe('Proje slug\'ı; boşsa DEFAULT_PROJECT kullanılır');
+export const environmentParam = z.string().min(1).optional()
+    .describe('Environment adı (X-Environment); boşsa DEFAULT_ENVIRONMENT kullanılır');
+export const definitionParam = z.record(z.unknown())
+    .describe('API komut gövdesi birebir geçirilir; şablon için ilgili *_get çıktısını ya da ngapps://schemas kaynağını kullanın');
+export const pagingParams = {
+    pageIndex: z.number().int().min(0).optional().describe('0 tabanlı sayfa numarası'),
+    pageLength: z.number().int().min(1).max(200).optional().describe('Sayfa boyu; platform varsayılanı 10'),
+    order: z.string().optional().describe('Sıralanacak alan adı'),
+    isDescending: z.boolean().optional()
+};
+export const readOnly = { readOnlyHint: true, openWorldHint: false };
+export const writes = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+export const updates = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+export const destructive = { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false };

package/dist/tools/components.js

@@ -0,0 +1,280 @@
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { normalizeComponentDefaults, componentDefaultsNote, clampBlockSizes, blockSizeNote, normalizeHeightTypes, heightTypeNote, withNormalization } from '../knowledge/normalize.js';
+import { eventContractsFor, eventPayloadNote } from '../knowledge/componentEvents.js';
+import { knowledgeFor, knowledgeNote } from '../knowledge/componentCatalog.js';
+import { componentUpdateBody, fetchHost, schemaParam, unwrap } from './screens.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const typeParam = z.enum(['web', 'mobile']).optional().describe('Hedef platform; varsayılan web');
+const kindParam = z.enum(['component', 'widget']).optional()
+    .describe("component: sayfaya konan tekil eleman. widget: kendi şeması olan kapsayıcı (container/modal/drawer)");
+const widgetTypeParam = z.enum(['container', 'modal', 'drawer']).optional()
+    .describe("kind:'widget' iken zorunlu");
+async function listComponents(platform, project, environment, applicationId, scope) {
+    const path = scope === 'all' ? `/components/${applicationId}/all` : `/components/${applicationId}`;
+    const response = await platform.tenant('GET', project, path, {
+        environment,
+        query: scope === 'all' ? undefined : { pageIndex: 0, pageLength: 999 }
+    });
+    return response?.data ?? [];
+}
+/**
+ * Yerleşim normalizasyonlarının ikisi de aynı katalog listesinden beslenir; tek okumada
+ * çıkarılır ki yazma yolları fazladan istek atmasın. Uygulamanın kendi sözlüğü okunur
+ * (platformun doğrulaması da onu çözer); `scope:'all'` aynı slug'ı birden fazla kayıtla
+ * döndürdüğü için burada kullanılmaz.
+ *
+ * - `maxSizes`: aynı slug birden fazla geçerse en geniş sınır alınır — fazla kırpmak, geçerli
+ *   bir gövdeyi bozmaktan kötüdür.
+ * - `autoHeights`: yalnız boolean dönen kayıtlar sözlüğe girer; bilinmeyen tip
+ *   `normalizeHeightTypes` tarafında auto sayılır (platform varsayılanı odur).
+ */
+export async function fetchComponentLayoutRules(platform, project, environment, applicationId) {
+    return componentLayoutRules(await listComponents(platform, project, environment, applicationId));
+}
+/** Katalog listesini zaten okumuş çağıranlar (component_update) ikinci istek atmasın diye ayrı. */
+export function componentLayoutRules(components) {
+    const maxSizes = new Map();
+    const autoHeights = new Map();
+    for (const component of components) {
+        const slug = typeof component.slug === 'string' ? component.slug : undefined;
+        if (!slug)
+            continue;
+        if (typeof component.isDefaultAutoHeight === 'boolean')
+            autoHeights.set(slug, component.isDefaultAutoHeight);
+        const blocks = (component.definition ?? {}).blocks;
+        if (!Array.isArray(blocks))
+            continue;
+        for (const block of blocks) {
+            const maxSize = block?.maxSize;
+            if (!maxSize)
+                continue;
+            const current = maxSizes.get(slug);
+            maxSizes.set(slug, {
+                w: Math.max(current?.w ?? 0, typeof maxSize.w === 'number' ? maxSize.w : 0) || undefined,
+                h: Math.max(current?.h ?? 0, typeof maxSize.h === 'number' ? maxSize.h : 0) || undefined
+            });
+        }
+    }
+    return { maxSizes, autoHeights };
+}
+/**
+ * Katalog okuması başarısız olsa da yazma isteği gitmeli, ama iki normalizasyonun düşüş davranışı
+ * AYNI DEĞİLDİR:
+ *
+ * - Kırpma atlanır — sınır bilgisi yoksa platformun kendi doğrulaması devreye girer.
+ * - `heightType` yine yazılır (bilinmeyen tip = auto) — burada atlamak, platformun yanlış
+ *   varsayılanını (`fixed`, `DesignComponentManagementSchema.cs:24`) kabul etmek demektir; en fazla
+ *   sekiz tipte (auth-layout/html/image/layout/qrcode/table/text-editor/video) fazladan yükseklik
+ *   üretir, atlamak ise her tipte içerik kırpar.
+ */
+export async function applyCatalogLayoutRules(platform, project, environment, applicationId, nodes) {
+    try {
+        const rules = await fetchComponentLayoutRules(platform, project, environment, applicationId);
+        return { clamped: clampBlockSizes(nodes, rules.maxSizes), heights: normalizeHeightTypes(nodes, rules.autoHeights) };
+    }
+    catch {
+        return { clamped: [], heights: normalizeHeightTypes(nodes, new Map()) };
+    }
+}
+/**
+ * slug → komponentin YAYDIĞI olay adları. `set_event`'in hedef doğrulaması bunu kullanır: platform
+ * uydurma bir olay adını 200 ile kabul eder ve bağ sessizce ölü kalır (destek masası koşumu B-03:
+ * rehberdeki `onClick` gerçekte `click`). Olay listesi boş dönen kayıtlar sözlüğe girmez — bilgi
+ * yoksa doğrulama da yapılmaz.
+ */
+export async function fetchComponentEventNames(platform, project, environment, applicationId) {
+    const events = new Map();
+    for (const component of await listComponents(platform, project, environment, applicationId)) {
+        const slug = typeof component.slug === 'string' ? component.slug : undefined;
+        const declared = (component.definition ?? {}).events;
+        if (!slug || !Array.isArray(declared) || declared.length === 0)
+            continue;
+        const names = declared
+            .map(event => String(event?.name ?? ''))
+            .filter(name => name.length > 0);
+        if (names.length > 0)
+            events.set(slug, [...new Set([...(events.get(slug) ?? []), ...names])]);
+    }
+    return events;
+}
+export function registerComponentTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('component_list', {
+        title: 'Komponent sözlüğünü listele',
+        description: "Sayfaya konabilecek kayıtlı komponent tiplerini (slug, name, kategori, droppable) kompakt listeler; tek tipin tam sözlüğü + davranış bilgisi için component_get, komponent modelinin geneli için platform_guide('component'). scope:'all' platformun varsayılan kataloğunu da getirir.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            scope: z.enum(['application', 'all']).optional().describe("application (varsayılan): bu uygulamanın sözlüğü. all: platform genelindeki tüm kayıtlı komponentler"),
+            includeHidden: z.boolean().optional().describe('isHide işaretli komponentleri de getirir')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, applicationId, scope, includeHidden }) => {
+        const components = await listComponents(platform, project, environment, applicationId, scope);
+        return {
+            components: components
+                .filter(component => includeHidden === true || component.isHide !== true)
+                .map(component => ({
+                id: component.id,
+                slug: component.slug,
+                name: component.name,
+                description: component.description,
+                categories: component.categories,
+                isDroppable: component.isDroppable,
+                kind: component.kind,
+                widgetType: component.widgetType
+            }))
+        };
+    }));
+    server.registerTool('component_get', {
+        title: 'Komponent sözlüğünü getir',
+        description: "Tek komponent tipinin tam sözlüğü: prop'lar (tip/enum/default), event'ler (yükleriyle), davranış bilgisi (knowledge) ve boyut sınırları. Şemaya uydurma prop yazmayın — yalnız burada dönenleri kullanın. Yanıtta guide alanı dönerse derin rehberi platform_guide ile okuyun (örn. html). slug ya da id ile çağrılır.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            slug: z.string().min(1).optional().describe("Komponent tip slug'ı, örn. 'button' ya da 'dropdown'"),
+            id: guid.optional().describe('slug verilmediyse zorunlu')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, applicationId, slug, id }) => {
+        if (!slug && !id)
+            throw new PlatformApiError("'slug' ya da 'id' parametrelerinden biri zorunlu.");
+        let component;
+        if (id) {
+            component = unwrap(await platform.tenant('GET', project, `/components/${applicationId}/${id}`, { environment }));
+        }
+        else {
+            const components = await listComponents(platform, project, environment, applicationId);
+            component = components.find(entry => entry.slug === slug);
+            if (!component) {
+                throw new PlatformApiError(`'${slug}' diye kayıtlı bir komponent yok. Kayıtlı slug'lar: ${components.map(entry => entry.slug).sort().join(', ')}`);
+            }
+        }
+        const definition = (component.definition ?? {});
+        const eventNames = Array.isArray(definition.events)
+            ? definition.events.map(event => String(event.name ?? ''))
+            : [];
+        const componentSlug = typeof component.slug === 'string' ? component.slug : undefined;
+        const knowledge = knowledgeFor(componentSlug);
+        return {
+            id: component.id,
+            slug: component.slug,
+            name: component.name,
+            description: component.description,
+            kind: component.kind,
+            widgetType: component.widgetType,
+            isDroppable: component.isDroppable,
+            props: definition.props,
+            defaults: definition.defaults,
+            events: eventContractsFor(componentSlug, eventNames),
+            eventPayloadNote,
+            ...(knowledge
+                ? {
+                    knowledge: {
+                        summary: knowledge.summary,
+                        ...(knowledge.behavior ? { behavior: knowledge.behavior } : {}),
+                        ...(knowledge.propNotes ? { propNotes: knowledge.propNotes } : {})
+                    },
+                    ...(knowledge.guide ? { guide: knowledge.guide } : {})
+                }
+                : { knowledgeNote }),
+            validations: definition.validations,
+            sizes: definition.blocks
+        };
+    }));
+    server.registerTool('component_create', {
+        title: 'Komponent/widget oluştur',
+        description: "Uygulamaya yeni komponent ya da widget (container/modal/drawer) kaydeder. definition = ComponentDefinitionManagementSchema (props/defaults/events/blocks); mevcut bir kaydı component_get ile alıp şablon olarak kullanın.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            name: z.string().min(1),
+            slug: z.string().min(1),
+            kind: kindParam,
+            type: typeParam,
+            widgetType: widgetTypeParam,
+            description: z.string().optional(),
+            icon: z.string().optional(),
+            categories: z.array(z.string()).optional(),
+            definition: z.record(z.unknown()).optional(),
+            schema: schemaParam.optional().describe("widget'ın kendi komponent ağacı"),
+            isHide: z.boolean().optional(),
+            isDroppable: z.boolean().optional(),
+            isSticky: z.boolean().optional(),
+            isDeletable: z.boolean().optional(),
+            isDefaultAutoHeight: z.boolean().optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, ...body }) => {
+        if (body.kind === 'widget' && !body.widgetType) {
+            throw new PlatformApiError("kind:'widget' için widgetType (container | modal | drawer) zorunludur.");
+        }
+        const fixed = normalizeComponentDefaults(body.schema);
+        const catalog = (body.schema ?? []).length > 0
+            ? await applyCatalogLayoutRules(platform, project, environment, applicationId, body.schema)
+            : { clamped: [], heights: [] };
+        return platform.tenant('POST', project, `/components/${applicationId}`, {
+            environment,
+            body: {
+                kind: 'component',
+                type: 'web',
+                categories: [],
+                definition: {},
+                schema: [],
+                ...Object.fromEntries(Object.entries(body).filter(([, value]) => value !== undefined))
+            }
+        }).then(response => withNormalization(response, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights)]));
+    }));
+    server.registerTool('component_update', {
+        title: 'Komponent güncelle',
+        description: "Komponenti SLUG ile günceller (platformdaki tek slug'la çalışan update ucu; silme id ile). PUT replace olduğu için gateway kaydı önce okur, yalnız verdiğiniz alanları değiştirip tam gövdeyi geri yazar.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            slug: z.string().min(1).describe("Güncellenecek komponentin slug'ı (id değil)"),
+            name: z.string().min(1).optional(),
+            type: typeParam,
+            widgetType: widgetTypeParam,
+            description: z.string().optional(),
+            icon: z.string().optional(),
+            categories: z.array(z.string()).optional(),
+            definition: z.record(z.unknown()).optional(),
+            schema: schemaParam.optional(),
+            isHide: z.boolean().optional(),
+            isDroppable: z.boolean().optional(),
+            isSticky: z.boolean().optional(),
+            isDeletable: z.boolean().optional(),
+            isDefaultAutoHeight: z.boolean().optional()
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, slug, ...changes }) => {
+        const components = await listComponents(platform, project, environment, applicationId);
+        const current = components.find(entry => entry.slug === slug);
+        if (!current) {
+            throw new PlatformApiError(`'${slug}' slug'lı komponent bu uygulamada yok. Kayıtlı slug'lar: ${components.map(entry => entry.slug).sort().join(', ')}`);
+        }
+        const detailed = current.id
+            ? await fetchHost(platform, 'component', project, environment, applicationId, String(current.id))
+            : current;
+        const overrides = Object.fromEntries(Object.entries(changes).filter(([, value]) => value !== undefined));
+        const fixed = normalizeComponentDefaults(overrides.schema);
+        const rules = componentLayoutRules(components);
+        const clamped = overrides.schema === undefined ? [] : clampBlockSizes(overrides.schema, rules.maxSizes);
+        const heights = overrides.schema === undefined ? [] : normalizeHeightTypes(overrides.schema, rules.autoHeights);
+        const body = componentUpdateBody({ ...detailed, applicationId }, overrides);
+        await platform.tenant('PUT', project, `/components/${applicationId}/${slug}`, { environment, body });
+        return withNormalization({ slug, changed: Object.keys(overrides), preserved: { schemaNodes: body.schema.length } }, [...componentDefaultsNote(fixed), ...blockSizeNote(clamped), ...heightTypeNote(heights)]);
+    }));
+    server.registerTool('component_delete', {
+        title: 'Komponent sil',
+        description: "Komponenti ID ile siler (update slug alır, delete id alır). Sayfalarda kullanılıyorsa önce dependency_graph module:'component' ile kontrol edin.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('DELETE', project, `/components/${applicationId}/${id}`, { environment })));
+}