@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/tools/projects.js

@@ -0,0 +1,152 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { projectCoverageGaps } from '../knowledge/coverage.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+function pick(entry, keys) {
+    if (!entry || typeof entry !== 'object')
+        return {};
+    return Object.fromEntries(keys
+        .map(key => [key, entry[key]])
+        .filter(([, value]) => value !== undefined && value !== null));
+}
+function rows(payload) {
+    const data = payload?.data;
+    return Array.isArray(data) ? data : [];
+}
+const applicationInput = z.object({
+    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')
+});
+const templateOptionsInput = z.object({
+    templateId: guid,
+    templateReceiveUpdates: z.boolean().optional()
+});
+export function registerProjectTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('project_list', {
+        title: 'Projeleri listele',
+        description: 'Organizasyondaki projeleri arar ve sayfalı listeler.',
+        inputSchema: { searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, args => platform.org('GET', '/projects', { query: args })));
+    server.registerTool('project_get', {
+        title: 'Proje getir',
+        description: 'Tek projeyi id ya da slug ile getirir; environment listesi de yanıttadır.',
+        inputSchema: { id: guid.optional(), slug: z.string().optional().describe('id verilmediyse zorunlu') },
+        annotations: readOnly
+    }, handle(config, args => {
+        if (args.id)
+            return platform.org('GET', `/projects/${args.id}`);
+        if (args.slug)
+            return platform.org('GET', `/p/${args.slug}`);
+        throw new Error("'id' ya da 'slug' parametrelerinden biri zorunlu.");
+    }));
+    server.registerTool('project_create', {
+        title: 'Proje oluştur',
+        description: "Yeni proje oluşturur. templateOptions verilmezse 'application' zorunludur (ilk application projeyle birlikte açılır). LoaderImage bu tool'da desteklenmez.",
+        inputSchema: {
+            name: z.string().min(1),
+            slug: z.string().min(1),
+            theme: z.string().optional().describe('Tema JSON\'u string olarak'),
+            application: applicationInput.optional(),
+            templateOptions: templateOptionsInput.optional().describe('Verilirse proje template\'ten kurulur (asenkron); sonucu project_list ile izleyin')
+        },
+        annotations: writes
+    }, handle(config, args => {
+        const form = new URLSearchParams({ Name: args.name, Slug: args.slug });
+        if (args.theme)
+            form.set('Theme', args.theme);
+        if (args.application) {
+            form.set('Application.Slug', args.application.slug);
+            form.set('Application.Name', args.application.name);
+            if (args.application.color)
+                form.set('Application.Color', args.application.color);
+            if (args.application.dns)
+                form.set('Application.Dns', args.application.dns);
+            if (args.application.type)
+                form.set('Application.Type', args.application.type);
+        }
+        if (args.templateOptions) {
+            form.set('TemplateOptions.TemplateId', args.templateOptions.templateId);
+            if (args.templateOptions.templateReceiveUpdates !== undefined) {
+                form.set('TemplateOptions.TemplateReceiveUpdates', String(args.templateOptions.templateReceiveUpdates));
+            }
+        }
+        return platform.org('POST', '/projects', { form });
+    }));
+    server.registerTool('project_update', {
+        title: 'Proje güncelle',
+        description: 'Proje adını, slug\'ını ve temasını günceller. LoaderImage bu tool\'da desteklenmez.',
+        inputSchema: {
+            id: guid,
+            name: z.string().min(1),
+            slug: z.string().optional(),
+            theme: z.string().optional()
+        },
+        annotations: updates
+    }, handle(config, args => {
+        const form = new URLSearchParams({ Name: args.name });
+        if (args.slug)
+            form.set('Slug', args.slug);
+        if (args.theme)
+            form.set('Theme', args.theme);
+        return platform.org('PUT', `/projects/${args.id}`, { form });
+    }));
+    server.registerTool('project_delete', {
+        title: 'Proje sil',
+        description: 'Projeyi tüm environment\'larıyla birlikte kalıcı olarak siler.',
+        inputSchema: { id: guid },
+        annotations: destructive
+    }, handle(config, args => platform.org('DELETE', `/projects/${args.id}`)));
+    server.registerTool('project_overview', {
+        title: 'Proje haritası',
+        description: 'Projenin kompakt envanteri: application\'lar, datasource+entity ağacı, microservice/workflow/query/SAYFA listeleri (yalnız id/ad/tip) + tutarlılık boşlukları (coverageGaps: kimlik var ama giriş sayfası yok, yazma ucu var ama sayfa yok). Var olan bir projede çalışmaya HER ZAMAN buradan başlayın; detay için ilgili *_get tool\'unu kullanın.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment }) => {
+        const projectSlug = platform.resolveProject(project);
+        const projectPayload = await platform.org('GET', `/p/${projectSlug}`);
+        const projectData = (projectPayload?.data ?? {});
+        const applicationsPayload = projectData.id
+            ? await platform.org('GET', '/applications', { query: { projectId: projectData.id, pageLength: 100 } })
+            : { data: [] };
+        const datasourceTreePayload = await platform.tenant('GET', projectSlug, '/datasources/tree', { environment });
+        const queriesPayload = await platform.tenant('GET', projectSlug, '/queries', { environment, query: { pageLength: 200 } });
+        const applications = [];
+        for (const applicationEntry of rows(applicationsPayload)) {
+            const applicationId = applicationEntry.id;
+            const [microservicesPayload, workflowsPayload, pagesPayload] = await Promise.all([
+                platform.tenant('GET', projectSlug, `/microservices/${applicationId}`, { environment, query: { pageLength: 200 } }).catch(() => undefined),
+                platform.tenant('GET', projectSlug, `/workflows/${applicationId}`, { environment, query: { pageLength: 200 } }).catch(() => undefined),
+                platform.tenant('GET', projectSlug, `/pages/${applicationId}`, { environment, query: { pageIndex: 0, pageLength: 200 } }).catch(() => undefined)
+            ]);
+            const microservices = rows(microservicesPayload).map(entry => pick(entry, ['id', 'slug', 'name', 'type', 'httpMethod', 'source', 'entityId', 'workflowId']));
+            const workflows = rows(workflowsPayload).map(entry => pick(entry, ['id', 'slug', 'name', 'type', 'entityId']));
+            const pages = rows(pagesPayload).map(entry => pick(entry, ['id', 'slug', 'name']));
+            const gaps = projectCoverageGaps({ pages, microservices, workflows });
+            applications.push({
+                ...pick(applicationEntry, ['id', 'slug', 'name', 'type']),
+                microservices,
+                workflows,
+                pages,
+                ...(gaps.length > 0 ? { coverageGaps: gaps } : {})
+            });
+        }
+        return {
+            project: pick(projectData, ['id', 'slug', 'name']),
+            environments: (Array.isArray(projectData.environments) ? projectData.environments : []).map(entry => pick(entry, ['id', 'name'])),
+            environment: platform.resolveEnvironment(environment),
+            applications,
+            datasources: rows(datasourceTreePayload).map(datasourceEntry => ({
+                ...pick(datasourceEntry, ['id', 'name', 'type']),
+                entities: (Array.isArray(datasourceEntry.entities) ? datasourceEntry.entities : [])
+                    .map(entry => pick(entry, ['id', 'slug', 'name']))
+            })),
+            queries: rows(queriesPayload).map(entry => pick(entry, ['id', 'name', 'datasourceId'])),
+            hint: 'Detay: entity_get/microservice_get/workflow_get (büyük kayıtlarda view:\'outline\'); değişiklik: *_patch.'
+        };
+    }));
+}

package/dist/tools/queries.js

@@ -0,0 +1,48 @@
+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 registerQueryTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('query_list', {
+        title: 'Query listele',
+        description: 'Projedeki query tanımlarını listeler.',
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/queries', { environment, query })));
+    server.registerTool('query_get', {
+        title: 'Query getir',
+        description: 'Tek query tanımını getirir; query_create için en iyi gövde şablonudur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/queries/${id}`, { environment })));
+    server.registerTool('query_create', {
+        title: 'Query oluştur',
+        description: 'Yeni query tanımlar. definition = CreateQueryCommand gövdesi.',
+        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
+        annotations: writes
+    }, handle(config, ({ project, environment, definition }) => platform.tenant('POST', project, '/queries', { environment, body: definition })));
+    server.registerTool('query_update', {
+        title: 'Query güncelle',
+        description: 'Query tanımını günceller. definition = UpdateQueryCommand gövdesi.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, definition }) => platform.tenant('PUT', project, `/queries/${id}`, { environment, body: definition })));
+    server.registerTool('query_delete', {
+        title: 'Query sil',
+        description: 'Query tanımını siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/queries/${id}`, { environment })));
+    server.registerTool('query_clone', {
+        title: 'Query klonla',
+        description: 'Query\'nin kopyasını oluşturur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: writes
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/queries/${id}/clone`, { environment })));
+    server.registerTool('query_preview', {
+        title: 'Query önizle',
+        description: 'Kaydedilmemiş query tanımını datasource üzerinde çalıştırır. definition = PreviewQueryCommand gövdesi.',
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, definition: definitionParam },
+        annotations: writes
+    }, handle(config, ({ project, environment, datasourceId, definition }) => platform.tenant('POST', project, `/queries/${datasourceId}/preview`, { environment, body: definition })));
+}

package/dist/tools/rows.js

@@ -0,0 +1,115 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const rowValues = z.record(z.unknown()).describe("Alan SLUG'ı → değer sözlüğü; anahtarlar entity_get çıktısındaki field SLUG'larıdır (name değil — name kullanmak 'Please enter a valid value' hatası verir)");
+export function registerRowTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('row_list', {
+        title: 'Satırları listele',
+        description: 'Entity satırlarını filtre/sıralama/sayfalama ile listeler; selectedFields verilirse satırlar bu alanlara indirgenir (id her zaman dahil).',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            selectedFields: z.array(z.string()).optional().describe('Dönen satırlar bu alan adlarına indirgenir, id her zaman dahildir; platform tam satırı hesapladığı için kırpma gateway tarafında yapılır'),
+            filters: z.array(z.record(z.unknown())).optional().describe('Platform Filter dizisi; biçim için row_list\'i filtresiz çağırıp Studio\'daki bir filtreyi referans alın'),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, entityId, ...body }) => {
+        const payload = await platform.tenant('POST', project, `/entities/${entityId}/row/list`, { environment, body });
+        const wanted = body.selectedFields ?? [];
+        if (!wanted.length || !payload || typeof payload !== 'object' || Array.isArray(payload))
+            return payload;
+        const rows = payload.data;
+        if (!Array.isArray(rows))
+            return payload;
+        const keep = new Set([...wanted.map(field => field.toLowerCase()), 'id']);
+        return {
+            ...payload,
+            data: rows.map(row => row && typeof row === 'object' && !Array.isArray(row)
+                ? Object.fromEntries(Object.entries(row).filter(([key]) => keep.has(key.toLowerCase())))
+                : row)
+        };
+    }));
+    server.registerTool('row_get', {
+        title: 'Satır getir',
+        description: 'Tek satırı id ile getirir.',
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: z.string().min(1) },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, id }) => platform.tenant('GET', project, `/entities/${entityId}/row/${encodeURIComponent(id)}`, { environment })));
+    server.registerTool('row_create', {
+        title: 'Satır ekle',
+        description: "Tek satır için 'row', çoklu ekleme için 'rows' verin (ikisi birden verilmez).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            row: rowValues.optional(),
+            rows: z.array(z.record(z.unknown())).optional()
+        },
+        annotations: writes
+    }, handle(config, ({ project, environment, entityId, row, rows }) => {
+        if (row && rows)
+            throw new Error("'row' ve 'rows' birlikte verilemez.");
+        if (rows)
+            return platform.tenant('POST', project, `/entities/${entityId}/row/bulk`, { environment, body: { rows } });
+        if (row)
+            return platform.tenant('POST', project, `/entities/${entityId}/row`, { environment, body: { row } });
+        throw new Error("'row' ya da 'rows' parametrelerinden biri zorunlu.");
+    }));
+    server.registerTool('row_update', {
+        title: 'Satır güncelle',
+        description: "Tek satır için 'row', çoklu güncelleme için 'rows' verin; satır id alanı gövdede olmalıdır.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            row: rowValues.optional(),
+            rows: z.array(z.record(z.unknown())).optional()
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, entityId, row, rows }) => {
+        if (row && rows)
+            throw new Error("'row' ve 'rows' birlikte verilemez.");
+        if (rows)
+            return platform.tenant('PUT', project, `/entities/${entityId}/row/bulk`, { environment, body: { rows } });
+        if (row)
+            return platform.tenant('PUT', project, `/entities/${entityId}/row`, { environment, body: { row } });
+        throw new Error("'row' ya da 'rows' parametrelerinden biri zorunlu.");
+    }));
+    server.registerTool('row_delete', {
+        title: 'Satır sil',
+        description: "Tek satır için 'id', çoklu silme için 'ids' verin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            id: z.string().optional(),
+            ids: z.array(z.union([z.string(), z.number()])).optional()
+        },
+        annotations: destructive
+    }, handle(config, ({ project, environment, entityId, id, ids }) => {
+        if (id && ids)
+            throw new Error("'id' ve 'ids' birlikte verilemez.");
+        if (ids)
+            return platform.tenant('POST', project, `/entities/${entityId}/row/bulk/delete`, { environment, body: { rowIds: ids } });
+        if (id)
+            return platform.tenant('DELETE', project, `/entities/${entityId}/row/${encodeURIComponent(id)}`, { environment });
+        throw new Error("'id' ya da 'ids' parametrelerinden biri zorunlu.");
+    }));
+    server.registerTool('row_next_code', {
+        title: 'Sıradaki kodu üret',
+        description: 'Incremental tipli alan için sıradaki kodu döner.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            fieldId: guid,
+            prefix: z.string().optional(),
+            separator: z.string().optional(),
+            digitCount: z.number().int().optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, ...body }) => platform.tenant('POST', project, `/entities/${entityId}/row/next-code`, { environment, body })));
+}

package/dist/tools/screens.js

@@ -0,0 +1,97 @@
+import { PlatformApiError } from '../platform/errors.js';
+import { z } from 'zod';
+export const hostParam = z.enum(['page', 'layout', 'component'])
+    .describe("Akışın barındırıcısı: page | layout | component (widget de component'tir)");
+export const schemaParam = z.array(z.record(z.unknown()))
+    .describe('Komponent ağacı (DesignComponentManagementSchema listesi); verilmezse mevcut şema korunur');
+export const eventsParam = z.array(z.record(z.unknown()))
+    .describe("Sayfa/layout düzeyi olaylar: [{ name, value }] — value bir flow id'sidir");
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function identifiers(value) {
+    return asArray(value)
+        .map(entry => (entry && typeof entry === 'object' ? entry.id : entry))
+        .filter((id) => typeof id === 'string');
+}
+export function unwrap(payload) {
+    const data = payload?.data;
+    return ((data ?? payload) ?? {});
+}
+export function hostPath(host, applicationId, hostId) {
+    if (host === 'page')
+        return `/pages/${applicationId}/${hostId}`;
+    if (host === 'layout')
+        return `/layouts/${applicationId}/${hostId}`;
+    return `/components/${applicationId}/${hostId}`;
+}
+export function flowPath(host, applicationId, hostId, flowId) {
+    const root = host === 'page'
+        ? `/pages/${hostId}/flows`
+        : host === 'layout'
+            ? `/layouts/${hostId}/flows`
+            : `/components/${applicationId}/${hostId}/flows`;
+    return flowId ? `${root}/${flowId}` : root;
+}
+export function pageUpdateBody(page, overrides = {}) {
+    const layout = (page.layout ?? {});
+    return {
+        id: page.id,
+        applicationId: page.applicationId,
+        name: page.name,
+        slug: page.slug,
+        browserTitle: page.browserTitle ?? '',
+        schema: page.schema ?? [],
+        events: asArray(page.events).filter(event => event?.value),
+        middlewareIds: page.middlewareIds ?? [],
+        roleIds: Array.isArray(page.roleIds) ? page.roleIds : identifiers(page.roles),
+        layoutId: page.layoutId ?? layout.id ?? null,
+        ...overrides
+    };
+}
+export function layoutUpdateBody(layout, overrides = {}) {
+    return {
+        id: layout.id,
+        applicationId: layout.applicationId,
+        name: layout.name,
+        parameters: layout.parameters ?? null,
+        views: layout.views ?? [],
+        events: asArray(layout.events).filter(event => event?.value),
+        ...overrides
+    };
+}
+export function componentUpdateBody(component, overrides = {}) {
+    return {
+        applicationId: component.applicationId,
+        type: component.type ?? 'web',
+        widgetType: component.widgetType ?? null,
+        slug: component.slug,
+        name: component.name,
+        description: component.description ?? '',
+        icon: component.icon ?? '',
+        categories: component.categories ?? [],
+        definition: component.definition ?? {},
+        schema: component.schema ?? [],
+        isHide: component.isHide ?? false,
+        isDroppable: component.isDroppable ?? false,
+        isSticky: component.isSticky ?? false,
+        isDeletable: component.isDeletable ?? true,
+        isDefaultAutoHeight: component.isDefaultAutoHeight ?? false,
+        ...overrides
+    };
+}
+export async function fetchHost(platform, host, project, environment, applicationId, hostId) {
+    const payload = await platform.tenant('GET', project, hostPath(host, applicationId, hostId), { environment });
+    const record = unwrap(payload);
+    if (!record.id) {
+        throw new PlatformApiError(`${host} kaydı okunamadı (${hostId}); id doğru mu, application eşleşiyor mu kontrol edin.`);
+    }
+    return record;
+}
+export function hostUpdateBody(host, record, overrides = {}) {
+    if (host === 'page')
+        return pageUpdateBody(record, overrides);
+    if (host === 'layout')
+        return layoutUpdateBody(record, overrides);
+    return componentUpdateBody(record, overrides);
+}

package/dist/tools/templates.js

@@ -0,0 +1,65 @@
+import { guid, pagingParams, readOnly, writes, updates } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerTemplateTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('template_list', {
+        title: 'Şablonları listele',
+        description: "Organizasyonun proje şablonlarını listeler. project_create'in templateOptions.templateId parametresi buradan gelir.",
+        inputSchema: {
+            searchTerm: z.string().optional(),
+            sourceModule: z.string().optional().describe("Module filtresi, ör. 'project'"),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, query => platform.org('GET', '/templates', { query })));
+    server.registerTool('template_get', {
+        title: 'Şablon getir',
+        description: 'Tek şablonun künyesini getirir (sürüm, changelog, görseller).',
+        inputSchema: { id: guid },
+        annotations: readOnly
+    }, handle(config, ({ id }) => platform.org('GET', `/templates/${id}`)));
+    server.registerTool('template_items', {
+        title: 'Şablon içeriğini listele',
+        description: "Şablonun bir modüldeki kayıtlarını listeler (project_create'in templateOptions.filters'ını doldurmak için).",
+        inputSchema: {
+            id: guid,
+            module: z.string().describe("Module değeri: entity | microservice | workflow | page | layout | component | query | view …")
+        },
+        annotations: readOnly
+    }, handle(config, ({ id, module }) => platform.org('GET', `/templates/${id}/items`, { query: { module } })));
+    server.registerTool('template_create', {
+        title: 'Projeyi şablon olarak yayımla',
+        description: 'Mevcut projeden yeni bir şablon sürümü üretir. Görsel yükleme bu tool\'da desteklenmez (ikili aktarım kapsam dışı).',
+        inputSchema: {
+            projectId: guid,
+            name: z.string().min(1),
+            version: z.string().min(1).describe("Sürüm etiketi, ör. '1.0.0'"),
+            description: z.string().optional(),
+            changeLog: z.string().optional(),
+            environmentId: guid.optional().describe('Hangi environment\'ın içeriği paketlenecek; boşsa varsayılan')
+        },
+        annotations: writes
+    }, handle(config, ({ projectId, name, version, description, changeLog, environmentId }) => {
+        const form = new URLSearchParams({ Name: name, Version: version });
+        if (description)
+            form.set('Description', description);
+        if (changeLog)
+            form.set('ChangeLog', changeLog);
+        if (environmentId)
+            form.set('EnvironmentId', environmentId);
+        return platform.org('POST', `/projects/${projectId}/templates`, { form });
+    }));
+    server.registerTool('template_check_updates', {
+        title: 'Şablon güncellemesi var mı',
+        description: 'Şablondan kurulmuş projenin kaynak şablonunda yeni sürüm var mı kontrol eder.',
+        inputSchema: { projectId: guid },
+        annotations: readOnly
+    }, handle(config, ({ projectId }) => platform.org('GET', `/projects/${projectId}/templates/check-for-updates`)));
+    server.registerTool('template_receive_updates', {
+        title: 'Şablon güncellemelerini al',
+        description: 'Kaynak şablondaki güncellemeleri projeye uygular; önce template_check_updates ile neyin geleceğini görün. Proje içeriğini değiştirir.',
+        inputSchema: { projectId: guid },
+        annotations: updates
+    }, handle(config, ({ projectId }) => platform.org('POST', `/projects/${projectId}/templates/receive-updates`)));
+}

package/dist/tools/variables.js

@@ -0,0 +1,94 @@
+import { parseVariableEntries, mergeVariableEntries, withNormalization } from '../knowledge/normalize.js';
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const variablePath = (applicationId, pageId) => pageId ? `/variables/${applicationId}/${pageId}` : `/variables/${applicationId}`;
+const variablesParam = z.array(z.object({
+    key: z.string().min(1).describe("Değişken adı; sayfada state.page.<key> ile okunur"),
+    value: z.unknown().describe('Herhangi bir JSON değeri; nesne verirseniz alanlarına state.page.<key>.<alan> ile erişilir')
+})).min(1).describe("Değişken listesi: [{ key: 'MyTest', value: { isActive: true } }]. Gateway bunu platformun beklediği JSON string'e çevirir.");
+const replaceParam = z.boolean().optional()
+    .describe('true: seti komple bunlarla değiştir (diğer değişkenler silinir). Varsayılan false — gateway mevcut setle birleştirir.');
+export function registerVariableTools(server, platform) {
+    const config = platform.config;
+    const readEntries = async (project, environment, applicationId, pageId) => {
+        try {
+            const payload = await platform.tenant('GET', project, variablePath(applicationId, pageId), { environment });
+            const record = (payload?.data ?? payload);
+            return parseVariableEntries(record?.data);
+        }
+        catch {
+            return [];
+        }
+    };
+    const write = async (method, { project, environment, applicationId, pageId, variables, replace }) => {
+        const incoming = variables.map(entry => ({ key: entry.key, value: entry.value ?? null }));
+        const existing = replace === true ? [] : await readEntries(project, environment, applicationId, pageId);
+        const merged = mergeVariableEntries(existing, incoming, replace === true);
+        const response = await platform.tenant(method, project, variablePath(applicationId, pageId), {
+            environment,
+            body: {
+                applicationId,
+                ...(pageId ? { pageId } : {}),
+                data: JSON.stringify(merged.entries)
+            }
+        });
+        return withNormalization({
+            scope: pageId ? 'page' : 'application',
+            variables: merged.entries.map(entry => entry.key),
+            response
+        }, [
+            ...merged.fixes,
+            `data alanı JSON string'e çevrildi (platform sözleşmesi: "[{\\"key\\":…,\\"value\\":…}]") — dizi olarak gönderilse Studio çalışma zamanı okuyamaz`
+        ]);
+    };
+    server.registerTool('variable_list', {
+        title: 'Değişkenleri getir',
+        description: "Application (pageId verilirse sayfa) değişken setini getirir. Platform seti tek kayıtta ve JSON STRING olarak tutar; gateway çözüp [{key, value}] dizisi döndürür. Sayfada okuma yolu: state.page.<key> (uygulama düzeyinde state.app.<key>).",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, pageId: guid.optional() },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, applicationId, pageId }) => ({
+        scope: pageId ? 'page' : 'application',
+        applicationId,
+        ...(pageId ? { pageId } : {}),
+        variables: await readEntries(project, environment, applicationId, pageId)
+    })));
+    server.registerTool('variable_pages', {
+        title: 'Sayfa değişkenlerini listele',
+        description: 'Application altında sayfa bazlı tanımlanmış değişken setlerini listeler.',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, applicationId }) => platform.tenant('GET', project, `/variables/${applicationId}/pages`, { environment })));
+    server.registerTool('variable_create', {
+        title: 'Değişken tanımla',
+        description: "Application (pageId verilirse sayfa) değişkeni tanımlar. Platform uygulama/sayfa başına TEK kayıt tutar ve seti komple değiştirir; gateway mevcut setle birleştirir (replace: true ile ezersiniz). Sayfada kullanım: prop { type:'code', ref:\"{{ state.page.<key>.<alan> }}\" } ya da flow'da value { type:'state', ref:'<key>' }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            pageId: guid.optional().describe('Verilirse sayfa düzeyi (state.page), verilmezse uygulama düzeyi (state.app)'),
+            variables: variablesParam,
+            replace: replaceParam
+        },
+        annotations: writes
+    }, handle(config, input => write('POST', input)));
+    server.registerTool('variable_update', {
+        title: 'Değişken güncelle',
+        description: "Var olan değişken setini günceller (variable_create zaten kayıt varsa update'e düşer; ikisi de aynı sonucu verir). Anahtar bazında birleştirir, replace: true ile seti komple değiştirir.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            pageId: guid.optional(),
+            variables: variablesParam,
+            replace: replaceParam
+        },
+        annotations: updates
+    }, handle(config, input => write('PUT', input)));
+    server.registerTool('variable_delete', {
+        title: 'Değişken setini sil',
+        description: "Application (pageId verilirse sayfa) değişken setinin TAMAMINI siler — tek değişken silmek için variable_update'e kalan listeyi replace: true ile gönderin.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, pageId: guid.optional() },
+        annotations: destructive
+    }, handle(config, ({ project, environment, applicationId, pageId }) => platform.tenant('DELETE', project, variablePath(applicationId, pageId), { environment })));
+}

package/dist/tools/views.js

@@ -0,0 +1,58 @@
+import { normalizeViewDefinition, viewAliasNote, withNormalization } from '../knowledge/normalize.js';
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerViewTools(server, platform) {
+    const config = platform.config;
+    const normalizeSource = (definition) => {
+        const { fixes, errors } = normalizeViewDefinition(definition);
+        if (errors.length > 0)
+            throw new PlatformApiError(errors.join(' · '), 400);
+        return fixes;
+    };
+    server.registerTool('view_list', {
+        title: 'View listele',
+        description: 'Projedeki view arama indekslerini listeler. DİKKAT: view modülü RAPORLAMA/özet için DEĞİL, tam metin (global) ARAMA içindir.',
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/views', { environment, query })));
+    server.registerTool('view_get', {
+        title: 'View getir',
+        description: 'Tek view tanımını getirir; view_create için en iyi gövde şablonudur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/views/${id}`, { environment })));
+    server.registerTool('view_create', {
+        title: 'View oluştur',
+        description: "TAM METİN ARAMA indeksi tanımlar (definition = CreateViewCommand; gövde şeması ngapps://schemas/CreateViewCommand, analizör sözlüğü platform_guide('view')) — raporlama/agregasyon aracı DEĞİLDİR. Seçilen tablo/alanlar analizörden (tokenizer/dil) geçirilip slug adlı projeksiyon tablosuna indekslenir; tüketimi source:'view' microservice'idir ve o uç ZORUNLU 'searchText' parametresi ister (+limit/offset). Rapor/özet için raw query (query_create) + query kaynaklı microservice kullanın. Birden çok entity verilebilir (entities: [{entityId, alias}], fields alias'la bağlanır: viewEntityAlias) ama bu JOIN DEĞİLDİR: her tablo ayrı ayrı indekslenir, aralarında ilişki tanımı yoktur ve eşleşme hangi tablodan geldiyse dönen kayıt o tablonun satırıdır. İlişkili içeriği tek kayıtta aratmak için denormalize bir alan kullanın (yorum metnini talebe yazan automation + tek entity'li view).",
+        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, definition }) => {
+        const fixes = normalizeSource(definition);
+        const response = await platform.tenant('POST', project, '/views', { environment, body: definition });
+        return withNormalization(response, viewAliasNote(fixes));
+    }));
+    server.registerTool('view_update', {
+        title: 'View güncelle',
+        description: "View tanımını günceller (definition = UpdateViewCommand, şema ngapps://schemas/UpdateViewCommand); mevcut hâli view_get ile alın. UpdateViewCommand'da datasourceId YOKTUR (create'te bağlanır). DİKKAT: view_get alanları 'viewEntityId' ile döndürür, yazma tarafı 'viewEntityAlias' ister — okuduğunuzu birebir geri yazarsanız gateway id'yi alias'a çevirir, çeviremezse isteği reddeder.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, definition }) => {
+        const fixes = normalizeSource(definition);
+        const response = await platform.tenant('PUT', project, `/views/${id}`, { environment, body: definition });
+        return withNormalization(response, viewAliasNote(fixes));
+    }));
+    server.registerTool('view_delete', {
+        title: 'View sil',
+        description: 'View projeksiyonunu siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/views/${id}`, { environment })));
+    server.registerTool('view_rebuild', {
+        title: 'View yeniden kur',
+        description: 'View projeksiyon tablosunu yeniden inşa eder (veri değişikliklerinden sonra senkron için).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: writes
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/views/${id}/rebuild`, { environment })));
+}