@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/tools/flows.js

@@ -0,0 +1,226 @@
+import { fetchHost, flowPath, hostParam, hostUpdateBody, unwrap } from './screens.js';
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { normalizeFlowSteps, withNormalization } from '../knowledge/normalize.js';
+import { flowBodyWarnings } from '../knowledge/coverage.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { policyRules } from '../knowledge/rules.js';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+const stepsParam = z.array(z.record(z.unknown())).describe("Adım listesi (StepManagementSchema: { stepId, name, type, kind, args, branches }). DİKKAT: branches[].nextStepId bir GUID değil, hedef adımın stepId STRING'idir; dal ADI motorun anahtarıdır ve start/setter/code adımlarında 'always' olmak zorundadır. Tam şablon: ngapps://examples/flow-load-table (ya da flow_get çıktısı); adım tipleri ve setter/parameters şekli platform_guide('page') Kural 1c.");
+const policyOverrideParam = z.boolean().optional();
+const flowIdParam = guid.describe("Akış id'si; şemadaki events[].value bu id'dir");
+function flowSummary(flow) {
+    return {
+        id: flow.id,
+        name: flow.name,
+        slug: flow.slug,
+        steps: Array.isArray(flow.steps) ? flow.steps.length : 0,
+        errorSteps: Array.isArray(flow.errorSteps) ? flow.errorSteps.length : 0
+    };
+}
+async function hostEnvelope(platform, host, project, environment, applicationId, hostId) {
+    const record = await fetchHost(platform, host, project, environment, applicationId, hostId);
+    return { [host]: hostUpdateBody(host, { ...record, applicationId }) };
+}
+async function requiredParameterWarnings(platform, project, environment, applicationId, steps) {
+    const warnings = [];
+    const microserviceSteps = steps
+        .map(step => ({ step, args: (step.args ?? {}) }))
+        .filter(entry => entry.step.type === 'microservice' && typeof entry.args.microserviceId === 'string');
+    const requiredFiltersByMicroservice = new Map();
+    const paginationByMicroservice = new Map();
+    for (const microserviceId of new Set(microserviceSteps.map(entry => entry.args.microserviceId))) {
+        try {
+            const definition = unwrap(await platform.tenant('GET', project, `/microservices/${applicationId}/${microserviceId}`, { environment }));
+            const parameters = (definition.sourceParameters ?? {});
+            const flattenFilters = (filters) => filters
+                .filter((filter) => Boolean(filter) && typeof filter === 'object')
+                .flatMap(filter => [filter, ...flattenFilters(Array.isArray(filter.children) ? filter.children : [])]);
+            // Uç okunduğunda filtrede fieldSlug YOKTUR (TableFilter yalnız fieldId taşır) — parametre
+            // ADI, platformun ürettiği parameterScheme'de durur: HandleFilters her dış kaynaklı filtre
+            // için { id: <alan id>, name: <alan slug'ı ya da 'alias.slug'>, source } satırı yazar
+            // (Microservice.SourceEntityParameterScheme:1031). Eskiden fieldId GUID'i parametre adıyla
+            // karşılaştırılıyordu ve zorunlu filtreli her uçta uyarı HER ZAMAN çıkıyordu (crm koşumu B-13).
+            const parameterNameByFieldId = new Map((Array.isArray(definition.parameterScheme) ? definition.parameterScheme : [])
+                .filter((item) => Boolean(item) && typeof item === 'object')
+                .map(item => [String(item.id ?? ''), String(item.name ?? '')])
+                .filter(([id, name]) => id !== '' && name !== ''));
+            requiredFiltersByMicroservice.set(microserviceId, flattenFilters(Array.isArray(parameters.filters) ? parameters.filters : [])
+                .filter(filter => filter.isRequired === true && filter.source !== 'expression')
+                .map(filter => String(filter.fieldSlug ?? parameterNameByFieldId.get(String(filter.fieldId ?? '')) ?? '')));
+            const limit = (parameters.limit ?? null);
+            if (limit && typeof limit.name === 'string' && limit.name.length > 0) {
+                paginationByMicroservice.set(microserviceId, { limitName: limit.name, offsetName: String(limit.offset ?? '') });
+            }
+        }
+        catch {
+            requiredFiltersByMicroservice.set(microserviceId, []);
+        }
+    }
+    const rowsConsumers = rowsTargetsByStepName(steps);
+    for (const entry of microserviceSteps) {
+        const providedParameterNames = (Array.isArray(entry.args.parameters) ? entry.args.parameters : [])
+            .filter((parameter) => Boolean(parameter) && typeof parameter === 'object')
+            .map(parameter => String(parameter.name ?? ''));
+        const missing = (requiredFiltersByMicroservice.get(entry.args.microserviceId) ?? [])
+            .filter(slug => slug && !providedParameterNames.includes(slug));
+        if (missing.length > 0) {
+            warnings.push(`FLOW-003: '${entry.step.stepId ?? entry.step.name}' adımının çağırdığı microservice'in zorunlu (isRequired) filtre parametreleri eksik: ${missing.join(', ')} — runtime'da MissingParameterException verir. args.parameters'a ekleyin; kimlik parametresiyse kalıcı çözüm middleware + user.id filtresidir (platform_guide('middleware')).`);
+        }
+        const pagination = paginationByMicroservice.get(entry.args.microserviceId);
+        const rowsTarget = rowsConsumers.get(String(entry.step.name ?? ''));
+        if (!pagination || !rowsTarget)
+            continue;
+        const missingPagination = [pagination.limitName, pagination.offsetName]
+            .filter(name => name.length > 0 && !providedParameterNames.includes(name));
+        if (missingPagination.length > 0) {
+            warnings.push(`FLOW-013: '${entry.step.stepId ?? entry.step.name}' adımının sonucu '${rowsTarget}' komponentinin rows prop'una yazılıyor ama uç query-string'ten ${missingPagination.join('/')} alırken adım bunları GEÇMİYOR — TableMicroserviceExecutor.cs:178 sayfalamayı yalnız limit doluysa uygular, yani sunucu her çağrıda TÜM kayıtları döndürür ve tablonun pagination olayı yeni sayfa çekemez. Her biri için args.parameters'a { name: '<ad>', type: 'text', source: 'query-string', value: { type: 'property', ref: { source: 'component', element: '${rowsTarget}', property: '<ad>' } } } ekleyin; tabloda ayrıca isPaginated: true ve pagination olayı bu akışa bağlı olmalı.`);
+        }
+    }
+    return warnings;
+}
+/**
+ * Hangi microservice adımının sonucu bir komponentin `rows` prop'una yazılıyor: setter iteratee'sinin
+ * storage anahtarı (mapping.source doluysa o, değilse value.ref — setter.ts:161) adımın ADIdır.
+ * Liste akışını böyle tanıyoruz; dönen sözlük adım adı → hedef elementId.
+ */
+function rowsTargetsByStepName(steps) {
+    const targets = new Map();
+    for (const step of steps.filter(step => step.type === 'setter')) {
+        const iteratees = Array.isArray((step.args ?? {}).iteratees)
+            ? (step.args ?? {}).iteratees
+            : [];
+        for (const iteratee of iteratees.filter((iteratee) => Boolean(iteratee) && typeof iteratee === 'object')) {
+            if (iteratee.property !== 'rows')
+                continue;
+            const mapping = (iteratee.mapping ?? {});
+            const value = (iteratee.value ?? {});
+            const reference = typeof mapping.source === 'string' && mapping.source.length > 0
+                ? mapping.source
+                : typeof value.ref === 'string' ? value.ref : '';
+            const stepName = reference.split('.')[0] ?? '';
+            if (stepName.length > 0 && typeof iteratee.element === 'string')
+                targets.set(stepName, iteratee.element);
+        }
+    }
+    return targets;
+}
+export function registerFlowTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('flow_list', {
+        title: 'Akışları listele',
+        description: "Barındırıcının olay akışlarını listeler. Sayfada ayrı bir liste ucu vardır; layout ve komponentte akışlar kaydın kendi gövdesinden okunur.",
+        inputSchema: { project: projectParam, environment: environmentParam, host: hostParam, applicationId: guid, hostId: guid },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, host, applicationId, hostId }) => {
+        if (host === 'page') {
+            const payload = await platform.tenant('GET', project, flowPath('page', applicationId, hostId), { environment });
+            return { flows: (payload?.data ?? []).map(flowSummary) };
+        }
+        const record = await fetchHost(platform, host, project, environment, applicationId, hostId);
+        return { flows: (Array.isArray(record.flows) ? record.flows : []).map(flowSummary) };
+    }));
+    server.registerTool('flow_get', {
+        title: 'Akış getir',
+        description: 'Tek akışı adımlarıyla getirir; yeni akış yazarken en iyi şablon budur.',
+        inputSchema: { project: projectParam, environment: environmentParam, host: hostParam, applicationId: guid, hostId: guid, flowId: flowIdParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, host, applicationId, hostId, flowId }) => platform.tenant('GET', project, flowPath(host, applicationId, hostId, flowId), { environment })));
+    server.registerTool('flow_create', {
+        title: 'Akış oluştur',
+        description: "Sayfa/layout/komponent için olay akışı oluşturur. Platform bu uçta barındırıcının TAM gövdesini de ister (akış ile şemadaki olay bağı tek işlemde tutarlı kalsın diye); gateway barındırıcıyı okuyup gövdeye kendisi koyar. Akışı bir komponent olayına bağlamak ayrı adımdır: page_schema_patch ile set_event {target, event, eventValue: <flow id>}.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            host: hostParam,
+            applicationId: guid,
+            hostId: guid,
+            name: z.string().min(1),
+            slug: z.string().min(1),
+            steps: stepsParam,
+            errorSteps: stepsParam.optional(),
+            flowId: guid.optional().describe('Verilmezse platform üretir; şemaya önceden bağlamak için kendiniz üretebilirsiniz'),
+            policyOverride: policyOverrideParam
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, host, applicationId, hostId, name, slug, steps, errorSteps, flowId, policyOverride }) => {
+        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const resolvedFlowId = flowId ?? randomUUID();
+        const flow = {
+            id: resolvedFlowId,
+            name,
+            slug,
+            steps,
+            errorSteps: errorSteps ?? [],
+            ...(host === 'page' ? { pageId: hostId } : host === 'layout' ? { layoutId: hostId } : { componentId: hostId })
+        };
+        const normalized = [...normalizeFlowSteps(flow.steps), ...normalizeFlowSteps(flow.errorSteps)];
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'flow', flow, { operation: 'create' }, policyOverride));
+        const parameterWarnings = [
+            ...await requiredParameterWarnings(platform, project, environment, applicationId, steps),
+            ...flowBodyWarnings(steps)
+        ];
+        await platform.tenant('POST', project, flowPath(host, applicationId, hostId), { environment, body: { flow, ...envelope } });
+        return attachFindings(withNormalization({
+            host,
+            hostId,
+            flow: { id: resolvedFlowId, name, slug, steps: steps.length },
+            ...(parameterWarnings.length > 0 ? { parameterWarnings } : {}),
+            hint: "Akışı bir olaya bağlamak için: page_schema_patch ops:[{op:'set_event', target:<elementId>, event:'<component_get events listesindeki ad>', eventValue:<flow id>}]. Olay adları komponente özeldir ve 'on' ÖNEKİ ALMAZ (button → 'click', form → 'submit', table → 'mount'/'select'/'sort'…); uydurma ad 200 döner ama bağ sessizce ölü kalır — gateway PAGE-008 ile yakalar."
+        }, normalized), findings);
+    }));
+    server.registerTool('flow_update', {
+        title: 'Akış güncelle',
+        description: 'Akışın adını/adımlarını değiştirir. Gövde replace\'tir: verilen steps listesi akışın yeni tam hâlidir. Barındırıcı gövdesini gateway ekler.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            host: hostParam,
+            applicationId: guid,
+            hostId: guid,
+            flowId: flowIdParam,
+            name: z.string().min(1).optional(),
+            slug: z.string().min(1).optional(),
+            steps: stepsParam.optional(),
+            errorSteps: stepsParam.optional(),
+            policyOverride: policyOverrideParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, host, applicationId, hostId, flowId, name, slug, steps, errorSteps, policyOverride }) => {
+        const current = unwrap(await platform.tenant('GET', project, flowPath(host, applicationId, hostId, flowId), { environment }));
+        if (!current.id)
+            throw new PlatformApiError(`'${flowId}' id'li akış bulunamadı; flow_list ile doğrulayın.`);
+        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const flow = {
+            id: flowId,
+            name: name ?? current.name,
+            slug: slug ?? current.slug,
+            steps: steps ?? current.steps ?? [],
+            errorSteps: errorSteps ?? current.errorSteps ?? [],
+            ...(host === 'page' ? { pageId: hostId } : host === 'layout' ? { layoutId: hostId } : { componentId: hostId })
+        };
+        const authored = { steps: steps ?? [], errorSteps: errorSteps ?? [] };
+        const normalized = [...normalizeFlowSteps(authored.steps), ...normalizeFlowSteps(authored.errorSteps)];
+        const findings = steps || errorSteps
+            ? enforcePolicy(evaluatePolicy(config, policyRules, 'flow', authored, { operation: 'update' }, policyOverride))
+            : [];
+        const parameterWarnings = [
+            ...await requiredParameterWarnings(platform, project, environment, applicationId, flow.steps),
+            ...flowBodyWarnings(flow.steps)
+        ];
+        await platform.tenant('PUT', project, flowPath(host, applicationId, hostId, flowId), { environment, body: { flow, ...envelope } });
+        return attachFindings(withNormalization({ host, hostId, flow: flowSummary(flow), ...(parameterWarnings.length > 0 ? { parameterWarnings } : {}) }, normalized), findings);
+    }));
+    server.registerTool('flow_delete', {
+        title: 'Akış sil',
+        description: "Akışı siler. Bu uç GÖVDE ister (barındırıcı komutu) — gövdesiz silme şemadaki olay bağını sarkıtır; gateway gövdeyi kendisi kurar. Olay bağını da temizlemek için ayrıca page_schema_patch set_event ile eventValue'yu boşaltın.",
+        inputSchema: { project: projectParam, environment: environmentParam, host: hostParam, applicationId: guid, hostId: guid, flowId: flowIdParam },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, host, applicationId, hostId, flowId }) => {
+        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        await platform.tenant('DELETE', project, flowPath(host, applicationId, hostId, flowId), { environment, body: { id: flowId, ...envelope } });
+        return { deleted: flowId, host, hostId };
+    }));
+}

package/dist/tools/folders.js

@@ -0,0 +1,51 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerFolderTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('folder_list', {
+        title: 'Klasörleri listele',
+        description: 'Proje klasör ağacını listeler (drive/dosya organizasyonu).',
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), parentId: guid.optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/folders', { environment, query })));
+    server.registerTool('folder_get', {
+        title: 'Klasör getir',
+        description: 'Tek klasörü getirir; breadcrumb: true ile üst yol zinciri döner.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, breadcrumb: z.boolean().optional() },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, breadcrumb }) => platform.tenant('GET', project, breadcrumb ? `/folders/${id}/breadcrumb` : `/folders/${id}`, { environment })));
+    server.registerTool('folder_create', {
+        title: 'Klasör oluştur',
+        description: "Yeni klasör oluşturur (definition = CreateFolderCommand: { name, parentId? }). DİKKAT: fiziksel klasör adı ve depolama yolu ASCII'ye katlanır ('Donanım' → 'Donanim') ve aynı üst klasörde çakışırsa sonuna ' (1)' eklenir — kullanıcıya gösterilen displayName ham adı korur. Yanıttaki name/path katlanmış hâldir, dosya yollarını oradan okuyun.",
+        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
+        annotations: writes
+    }, handle(config, ({ project, environment, definition }) => platform.tenant('POST', project, '/folders', { environment, body: definition })));
+    server.registerTool('folder_update', {
+        title: 'Klasör yetkilerini güncelle',
+        description: "Klasörün YETKİLENDİRMESİNİ günceller — `UpdateFolderCommand`'ın alanları yalnız `middlewareIds` ve `roleIds`'tir. Ad değiştirmek için folder_rename kullanın; **klasör TAŞIMA (parentId değiştirme) platformda desteklenmiyor** — gövdeye parentId/name koyarsanız sessizce yok sayılır ve istek yine 200 döner (etkinlik turu Ç3).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            middlewareIds: z.array(guid).optional().describe('Klasöre erişimden önce koşacak middleware workflow id\'leri'),
+            roleIds: z.array(guid).optional().describe('Klasörü görebilecek roller; boş = kısıt yok')
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, middlewareIds, roleIds }) => platform.tenant('PUT', project, `/folders/${id}`, {
+        environment,
+        body: { id, middlewareIds: middlewareIds ?? [], roleIds: roleIds ?? [] }
+    })));
+    server.registerTool('folder_rename', {
+        title: 'Klasörü yeniden adlandır',
+        description: "Klasörün görünen adını (displayName) değiştirir; fiziksel depolama yolu (`name`/`path`) sabit kalır — bu kasıtlıdır, yüklenmiş dosyaların yolu kırılmasın diye. Üst klasörü değiştirmez (taşıma desteklenmiyor).",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, name: z.string().min(1) },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, name }) => platform.tenant('PATCH', project, `/folders/${id}/rename`, { environment, body: { name } })));
+    server.registerTool('folder_delete', {
+        title: 'Klasör sil',
+        description: 'Klasörü siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/folders/${id}`, { environment })));
+}

package/dist/tools/layouts.js

@@ -0,0 +1,105 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { normalizeComponentDefaults, componentDefaultsNote, blockSizeNote, heightTypeNote, invalidScreenEventNames, invalidWidgetTypeNodes, verticalGapWarnings, withNormalization } from '../knowledge/normalize.js';
+import { fetchHost, layoutUpdateBody, schemaParam, eventsParam } from './screens.js';
+import { applyCatalogLayoutRules } from './components.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const viewsParam = schemaParam.describe("Layout'un komponent ağacı. DİKKAT: layout'ta şema alanının adı 'schema' değil 'views'tir ve sayfa micro-op hattı (page_schema_patch) layout'a uygulanmaz. İçinde MUTLAKA bir { type: 'slot' } komponenti olmalı — sayfa içeriği YALNIZ slot'un içine render edilir, slot'suz layout'a bağlanan sayfalar boş görünür.");
+function slotWarning(views) {
+    const hasSlot = (nodes) => Array.isArray(nodes) && nodes.some(node => Boolean(node) && typeof node === 'object' &&
+        (node.type === 'slot' || hasSlot(node.children)));
+    return hasSlot(views)
+        ? []
+        : ["LAY-002: layout'ta 'slot' tipli komponent YOK — Studio ve runtime, sayfa şemasını yalnız layout'taki slot'un içine yerleştirir (page.mappers: layout varsa render şeması layout views'üdür); bu layout'a bağlanan her sayfanın içeriği görünmez olur. views'e bir { type: 'slot' } komponenti ekleyin ve page_state.layoutSlots ile doğrulayın."];
+}
+export function registerLayoutTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('layout_list', {
+        title: 'Layout listele',
+        description: "Uygulamanın layout'larını listeler; sayfalar layoutId ile bunlara bağlanır.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, applicationId, ...query }) => platform.tenant('GET', project, `/layouts/${applicationId}`, { environment, query })));
+    server.registerTool('layout_get', {
+        title: 'Layout getir',
+        description: "Layout'u komponent ağacı (views), widget'ları, akışları ve olaylarıyla getirir.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('GET', project, `/layouts/${applicationId}/${id}`, { environment })));
+    server.registerTool('layout_create', {
+        title: 'Layout oluştur',
+        description: "Yeni layout oluşturur. Şablon için mevcut bir layout'u layout_get ile alın; slot kurgusunu page_state çıktısındaki layoutSlots ile doğrulayın.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            name: z.string().min(1),
+            views: viewsParam.optional(),
+            events: eventsParam.optional(),
+            parameters: z.record(z.unknown()).optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, name, views, events, parameters }) => {
+        const badEvents = invalidScreenEventNames(events, 'LAY-004');
+        if (badEvents.length > 0)
+            throw new PlatformApiError(`Geçersiz layout olayı (istek gönderilmedi): ${badEvents.join(' · ')}`, 400);
+        const badWidgets = invalidWidgetTypeNodes(views, 'LAY-005');
+        if (badWidgets.length > 0)
+            throw new PlatformApiError(`Geçersiz widget düğümü (istek gönderilmedi): ${badWidgets.join(' · ')}`, 400);
+        const fixed = normalizeComponentDefaults(views);
+        const catalog = (views ?? []).length > 0
+            ? await applyCatalogLayoutRules(platform, project, environment, applicationId, views)
+            : { clamped: [], heights: [] };
+        const gaps = verticalGapWarnings(views ?? [], 'LAY-003 (uyarı)');
+        const response = await platform.tenant('POST', project, `/layouts/${applicationId}`, {
+            environment,
+            body: { name, views: views ?? [], events: events ?? [], parameters: parameters ?? null }
+        });
+        const normalized = withNormalization(response, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights), ...slotWarning(views)]);
+        if (gaps.length === 0 || !normalized || typeof normalized !== 'object')
+            return normalized;
+        return { ...normalized, layoutWarnings: gaps };
+    }));
+    server.registerTool('layout_update', {
+        title: 'Layout güncelle',
+        description: "Layout'u günceller. PUT replace olduğu için gateway kaydı önce okur, yalnız verdiğiniz alanları değiştirip tam gövdeyi geri yazar — views göndermezseniz mevcut ağaç korunur.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            id: guid,
+            name: z.string().min(1).optional(),
+            views: viewsParam.optional(),
+            events: eventsParam.optional(),
+            parameters: z.record(z.unknown()).optional()
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, id, ...changes }) => {
+        const overrides = Object.fromEntries(Object.entries(changes).filter(([, value]) => value !== undefined));
+        const badEvents = invalidScreenEventNames(overrides.events, 'LAY-004');
+        if (badEvents.length > 0)
+            throw new PlatformApiError(`Geçersiz layout olayı (istek gönderilmedi): ${badEvents.join(' · ')}`, 400);
+        const badWidgets = invalidWidgetTypeNodes(overrides.views, 'LAY-005');
+        if (badWidgets.length > 0)
+            throw new PlatformApiError(`Geçersiz widget düğümü (istek gönderilmedi): ${badWidgets.join(' · ')}`, 400);
+        const current = await fetchHost(platform, 'layout', project, environment, applicationId, id);
+        const fixed = normalizeComponentDefaults(overrides.views);
+        const catalog = overrides.views === undefined
+            ? { clamped: [], heights: [] }
+            : await applyCatalogLayoutRules(platform, project, environment, applicationId, overrides.views);
+        const body = layoutUpdateBody({ ...current, applicationId }, overrides);
+        await platform.tenant('PUT', project, `/layouts/${applicationId}/${id}`, { environment, body });
+        const gaps = overrides.views === undefined ? [] : verticalGapWarnings(body.views, 'LAY-003 (uyarı)');
+        const summary = { id, changed: Object.keys(overrides), preserved: { viewNodes: body.views.length } };
+        if (gaps.length > 0)
+            summary.layoutWarnings = gaps;
+        return withNormalization(summary, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights), ...slotWarning(body.views)]);
+    }));
+    server.registerTool('layout_delete', {
+        title: 'Layout sil',
+        description: "Layout'u siler; bu layout'a bağlı sayfalar layoutsuz kalır. Önce dependency_graph module:'layout' ile kontrol edin.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('DELETE', project, `/layouts/${applicationId}/${id}`, { environment })));
+}

package/dist/tools/microservices.js

@@ -0,0 +1,198 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { normalizeMicroserviceDefinition, withNormalization } from '../knowledge/normalize.js';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { microserviceOutline, resolvePart, resolvePatchOperations } from '../knowledge/outlines.js';
+import { policyRules } from '../knowledge/rules.js';
+import { handle } from '../platform/responses.js';
+import fastJsonPatch from 'fast-json-patch';
+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)');
+const patchOperationsParam = z.array(z.record(z.unknown())).min(1)
+    .describe("RFC 6902 JSON Patch işlemleri; path'leri view:'outline'/'part' ile keşfedin. Dizi öğelerinde indeks yerine seçici kullanılabilir: '/sourceParameters/joins[alias=customers]/path' — seçici gövde platforma gitmeden indekse çevrilir, çözülemezse istek hiç gönderilmez.");
+const executeInput = {
+    project: projectParam,
+    environment: environmentParam,
+    application: z.string().min(1).describe('Application slug\'ı'),
+    microservice: z.string().min(1).describe('Microservice slug\'ı'),
+    method: z.enum(['GET', 'POST', 'PUT', 'DELETE']).default('GET'),
+    routeParams: z.array(z.string()).optional(),
+    query: z.record(z.unknown()).optional(),
+    body: z.union([z.record(z.unknown()), z.array(z.record(z.unknown()))]).optional()
+        .describe('İstek gövdesi: tek nesne ya da nesne dizisi (bulk uçlar için)'),
+    headers: z.record(z.string()).optional().describe("İsteğe eklenecek header'lar. 'Authorization' verirseniz gateway KENDİ token'ını KOYMAZ — istek tamamen sizin kimliğinizle gider (middleware'li uçları üye token'ıyla test etmenin yolu budur)"),
+    anonymous: z.boolean().optional().describe("true: istek HİÇBİR Authorization header'ı olmadan gider — 'korumalı uç tokensız ne döner?' sorusunun cevabı budur (korumalı uçtan 401, anonim uçtan 200 beklenir). Gateway normalde her çağrıya kendi token'ını koyduğu için bu bayrak olmadan anonim erişim testi yapılamaz.")
+};
+function executePath(prefix, application, microservice, routeParams) {
+    const routeSuffix = routeParams && routeParams.length > 0
+        ? `/${routeParams.map(encodeURIComponent).join('/')}`
+        : '';
+    return `/${prefix}/${application}/${microservice}${routeSuffix}`;
+}
+/** Slug application_update ile değişebildiği için önbellek kısa ömürlüdür (yalnız aynı turdaki tekrar okumaları ucuzlatır). */
+const APPLICATION_SLUG_TTL_MS = 60_000;
+const applicationSlugCache = new Map();
+async function applicationSlug(platform, applicationId) {
+    const cached = applicationSlugCache.get(applicationId);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.slug;
+    try {
+        const payload = await platform.org('GET', `/applications/${applicationId}`);
+        const application = (payload?.data ?? payload);
+        const slug = typeof application.slug === 'string' && application.slug !== '' ? application.slug : undefined;
+        if (slug)
+            applicationSlugCache.set(applicationId, { slug, expiresAt: Date.now() + APPLICATION_SLUG_TTL_MS });
+        return slug;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Çalıştırma rotası `[Route("{project}")] + m/{application}/{microservice}` ve arama
+ * `m.Slug == microserviceSlug` ile yapılır (MicroservicesController:91,
+ * MicroserviceRepository.FindBySlugAsync) — yani yolu kuran alan `url` DEĞİL **slug**'dır ve
+ * proje öneki zorunludur. Ham curl ile anonim test yapmak isteyen bu yolu tahmin etmek zorunda
+ * kalıyordu (crm koşumu B-8): artık kayıt okunduğunda hazır geliyor.
+ */
+async function resolveRuntimeUrl(platform, project, environment, applicationId, definition) {
+    const slug = String(definition.slug ?? '');
+    const method = String(definition.httpMethod ?? 'get').toUpperCase();
+    const resolvedProject = platform.resolveProject(project);
+    const resolvedEnvironment = platform.resolveEnvironment(environment);
+    const application = await applicationSlug(platform, applicationId);
+    const path = `/${resolvedProject}/m/${application ?? '<application slug>'}/${slug}`;
+    return {
+        method,
+        path,
+        absolute: `${platform.config.tenantApiBaseUrl}${path}`,
+        headers: {
+            Host: `${platform.config.organization}.${platform.config.hostSuffix}`,
+            'X-Environment': resolvedEnvironment
+        },
+        note: `Yolu SLUG kurar, 'url' alanı ('${String(definition.url ?? '')}') rotaya girmez. Route parametreleri slug'ın ardına eklenir. Anonim erişim testi için microservice_execute'u anonymous: true ile çağırın; korumalı uçlarda 401, anonim uçlarda 200 beklenir.`
+    };
+}
+export function registerMicroserviceTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('microservice_list', {
+        title: 'Microservice listele',
+        description: 'Application altındaki microservice\'leri listeler.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            searchTerm: z.string().optional(),
+            httpMethod: z.string().optional(),
+            entityId: guid.optional(),
+            queryId: guid.optional(),
+            type: z.string().optional(),
+            isDefault: z.boolean().optional(),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, applicationId, ...query }) => platform.tenant('GET', project, `/microservices/${applicationId}`, { environment, query })));
+    server.registerTool('microservice_get', {
+        title: 'Microservice getir',
+        description: "Microservice tanımını getirir. Büyük tanımda önce view:'outline' (kaynak/alan özeti), sonra view:'part' ile tek parça çekin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            id: guid,
+            view: z.enum(['full', 'outline', 'part']).optional().describe('varsayılan full'),
+            part: z.string().optional().describe("view:'part' için yol, ör. sourceParameters.joins veya validations[0]")
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, applicationId, id, view, part }) => {
+        const payload = await platform.tenant('GET', project, `/microservices/${applicationId}/${id}`, { environment });
+        const definition = (payload?.data ?? payload);
+        if (view === 'part') {
+            if (!part)
+                throw new Error("view:'part' için 'part' parametresi zorunlu.");
+            return { part, value: resolvePart(definition, part) };
+        }
+        const resolvedUrl = await resolveRuntimeUrl(platform, project, environment, applicationId, definition);
+        if (view === 'outline')
+            return { ...microserviceOutline(definition), resolvedUrl };
+        return { ...payload, resolvedUrl };
+    }));
+    server.registerTool('microservice_create', {
+        title: 'Microservice oluştur',
+        description: "Yeni microservice tanımlar (definition = CreateMicroserviceCommand). İlk kullanımdan önce platform_guide('microservice') okuyun: kaynak seçimi (table > query) ve selectFields disiplini. Auth/oturum gerektiren uçlarda definition.middlewareIds ile middleware bağlayın; kimlik kapsaması filtrede source:'expression' + value:'user.id' ile yapılır (platform_guide('middleware')). Gövde politika kontrolünden geçer.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, definition, policyOverride }) => {
+        const normalized = normalizeMicroserviceDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'create' }, policyOverride));
+        const payload = await platform.tenant('POST', project, `/microservices/${applicationId}`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+    server.registerTool('microservice_update', {
+        title: 'Microservice güncelle',
+        description: 'Microservice tanımını günceller (tam gövde). Hedefli değişiklik için microservice_patch tercih edin. Gövde politika kontrolünden geçer.',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, id, definition, policyOverride }) => {
+        const normalized = normalizeMicroserviceDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'update' }, policyOverride));
+        const payload = await platform.tenant('PUT', project, `/microservices/${applicationId}/${id}`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+    server.registerTool('microservice_patch', {
+        title: 'Microservice\'e patch uygula',
+        description: 'Tam gövdeyi bağlama almadan hedefli değişiklik: gateway mevcut tanımı çeker, JSON Patch uygular, politika kontrolünden geçirir, geri yazar. Yanıt outline özetidir.',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid, operations: patchOperationsParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, id, operations, policyOverride }) => {
+        const current = await platform.tenant('GET', project, `/microservices/${applicationId}/${id}`, { environment });
+        const definition = structuredClone((current?.data ?? current));
+        const resolved = resolvePatchOperations(definition, operations);
+        const patched = fastJsonPatch.applyPatch(definition, resolved.operations, true, false).newDocument;
+        const normalized = normalizeMicroserviceDefinition(patched);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', patched, { operation: 'update' }, policyOverride));
+        await platform.tenant('PUT', project, `/microservices/${applicationId}/${id}`, { environment, body: patched });
+        return attachFindings(withNormalization({ applied: operations.length, outline: microserviceOutline(patched) }, [...normalized, ...resolved.notes.map(note => `patch yolu seçiciden indekse çözüldü: ${note}`)]), findings);
+    }));
+    server.registerTool('microservice_delete', {
+        title: 'Microservice sil',
+        description: 'Microservice tanımını siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('DELETE', project, `/microservices/${applicationId}/${id}`, { environment })));
+    server.registerTool('microservice_clone', {
+        title: 'Microservice klonla',
+        description: 'Microservice\'in kopyasını oluşturur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: writes
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microservices/${id}/clone`, { environment })));
+    server.registerTool('microservice_execute', {
+        title: 'Microservice çalıştır',
+        description: 'Kayıtlı microservice\'i gerçek runtime yolundan çalıştırır (POST /{project}/m/{application}/{microservice SLUG\'ı}). Dönen httpStatus microservice\'in kendi sonucudur (hata da geçerli çıktıdır); beklenmedik sonuçta microservice_debug ile adım adım inceleyin. Anonim erişim testi için anonymous: true.',
+        inputSchema: executeInput,
+        annotations: writes
+    }, handle(config, ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous }) => platform.tenantRaw(method, project, executePath('m', application, microservice, routeParams), { environment, query, body, headers, anonymous })));
+    server.registerTool('microservice_debug', {
+        title: 'Microservice debug',
+        description: 'Microservice\'i debug modunda çalıştırır; yanıtta adım adım executionItems ağacı döner (her adımın girdi/çıktısı).',
+        inputSchema: executeInput,
+        annotations: writes
+    }, handle(config, ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous }) => platform.tenantRaw(method, project, executePath('debug', application, microservice, routeParams), { environment, query, body, headers, anonymous })));
+    server.registerTool('microservice_preview', {
+        title: 'Microservice önizle',
+        description: 'Kaydedilmemiş microservice tanımını çalıştırır; kaydetmeden önce preview ile doğrulayın. definition = PreviewMicroserviceCommand gövdesi (previewParameters dahil).',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, definition, policyOverride }) => {
+        const normalized = normalizeMicroserviceDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'preview' }, policyOverride));
+        const payload = await platform.tenantRaw('POST', project, `/microservices/${applicationId}/preview`, { environment, body: definition });
+        return attachFindings(withNormalization(payload, normalized), findings);
+    }));
+    server.registerTool('microservice_job_history', {
+        title: 'Job geçmişi',
+        description: 'Zamanlanmış (job tipli) microservice\'in çalışma geçmişini listeler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, ...query }) => platform.tenant('GET', project, `/microservices/${id}/job-history`, { environment, query })));
+}