@appaflytech/zeyrek-ai-mcp 0.0.6 → 0.0.7

package/dist/tools/imports.js

@@ -0,0 +1,241 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, destructive } from './common.js';
+import { importChoicesShape, importChoicesSchema, importErrorPolicies, importRowActions, validateChoices } from './importSchemas.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { uploadFile } from './files.js';
+import { z } from 'zod';
+const localeParam = z.enum(['tr-TR', 'en-US']).optional()
+    .describe("Sayı, tarih ve Evet/Hayır yazımını çözen yerel ayar profili. Verilmezse backend proje dilinden seçer. Aynı dosya 'en-US' ile okunduğunda '15.03.2024' ve '42.500,00' metne düşer — bu kayıp değil, kayıpsızlık kuralıdır.");
+const csvParam = z.object({
+    delimiter: z.string().min(1).optional().describe("Sütun ayracı; verilmezse ilk 20 satırdan tespit edilir (';' ',' tab '|')"),
+    encoding: z.string().min(1).optional().describe("Kodlama; verilmezse BOM'dan ya da UTF-8 denemesinden tespit edilir, başarısızsa windows-1254")
+}).optional().describe('Yalnız CSV için; tespit yanlışsa buradan ezilir');
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function candidateNote(candidate) {
+    const columns = asArray(candidate.sourceColumns).join(' → ');
+    const target = candidate.target?.existingEntityId
+        ? 'mevcut tablo'
+        : typeof candidate.target?.newTableName === 'string' ? `yeni tablo '${candidate.target.newTableName}'` : 'metin';
+    return `${columns} → ${target} (${String(candidate.kind ?? '?')}, öneri: ${String(candidate.recommended ?? '-')})`;
+}
+export function assertNotProduction(tool, environment, config) {
+    if ((environment ?? config.defaultEnvironment) !== 'production')
+        return;
+    throw new PlatformApiError(`${tool}: production'a içe aktarma yapılmaz; geri alma ve iptal de gönderilmez — hedef environment 'development' ya da bir dal olmalı. Production'a veri taşımak insan onaylı deployment işidir.`, 400);
+}
+export function registerImportTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('import_analyze', {
+        title: 'Excel/CSV/JSON dosyasını analiz et',
+        description: "Yüklenmiş bir xlsx/csv/json dosyasının sayfalarını, sütunlarını, çıkarılan tiplerini, ilişki adaylarını ve ilk satırlarını tek yanıtta döner. JSON kökü dört biçimden biridir: nesne dizisi (tek sayfa), tek nesne (tek satır), her özelliği nesne dizisi olan nesne (özellik başına bir sayfa) ve row_export'un { meta, data } gövdesi (meta okunmaz, veri tek sayfa olur); okunamayan dosya gerekçesiyle 400 alır. Satırı gövdede taşımaz — 300 satırlık bir tabloyu row_create ile elle yazmak yerine dosyayı `path` ile verin, gateway önce yükler. Zincir: import_analyze → import_plan → import_run → import_status. Hiçbir satır yazılmaz, bu bir sorgudur.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            datasourceId: guid.describe('Tabloların açılacağı datasource (datasource_list; isBuiltIn olan projenin kendi veritabanıdır)'),
+            fileId: guid.optional().describe('Daha önce file_upload ile yüklenmiş dosya; `path` ile birlikte verilmez'),
+            path: z.string().min(1).optional().describe("Gateway sürecinin okuyabildiği yerel dosya yolu; gateway önce file_upload'ı çağırır ve dönen fileId'yi yanıta ekler"),
+            locale: localeParam,
+            headerRow: z.number().int().min(0).optional().describe("Başlık satırının 1 tabanlı numarası; 0 = başlık yok, varsayılan 1. JSON'da yok sayılır: başlık anahtarlardır ve her zaman 1 olur"),
+            csv: csvParam
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, datasourceId, fileId, path, locale, headerRow, csv }) => {
+        if ((fileId === undefined) === (path === undefined)) {
+            throw new PlatformApiError('import_analyze: `fileId` ya da `path` parametrelerinden tam olarak biri verilmeli — `path` gateway sürecinin okuyabildiği yerel dosya, `fileId` daha önce file_upload ile yüklenmiş dosya.');
+        }
+        const notes = [];
+        let resolvedFileId = fileId;
+        if (path !== undefined) {
+            const uploaded = await uploadFile(platform, { project, environment, path });
+            const uploadedFile = uploaded?.data;
+            if (typeof uploadedFile?.id !== 'string') {
+                throw new PlatformApiError(`import_analyze: dosya yüklendi ama yanıtta fileId yok (${path}).`);
+            }
+            resolvedFileId = uploadedFile.id;
+            notes.push(`Dosya yüklendi: fileId ${resolvedFileId}`);
+        }
+        const body = {
+            fileId: resolvedFileId,
+            ...(locale === undefined ? {} : { locale }),
+            ...(headerRow === undefined ? {} : { headerRow }),
+            ...(csv === undefined ? {} : { csv })
+        };
+        let payload;
+        try {
+            payload = await platform.tenant('POST', project, `/entities/${datasourceId}/import/analyze`, { environment, body });
+        }
+        catch (error) {
+            if (error instanceof PlatformApiError && error.code === 'ImportFileUnreadableException') {
+                throw new PlatformApiError(`${error.message} CSV ise \`csv.delimiter\` ve \`csv.encoding\` verip yeniden deneyin; .xls dosyasını önce .xlsx olarak kaydedin.`, error.status, error.code);
+            }
+            throw error;
+        }
+        const analysis = payload?.data;
+        const sheets = asArray(analysis?.sheets);
+        const candidates = sheets.flatMap(sheet => asArray(sheet.relationCandidates));
+        const summary = {
+            sheets: sheets.length,
+            rows: sheets.reduce((total, sheet) => total + (typeof sheet.rowCount === 'number' ? sheet.rowCount : 0), 0),
+            relationCandidates: candidates.length,
+            warnings: asArray(analysis?.warnings).length
+        };
+        if (candidates.length > 0)
+            notes.push(`İlişki adayları: ${candidates.map(candidateNote).join('; ')}`);
+        const unconvertible = sheets.flatMap(sheet => asArray(sheet.columns))
+            .filter(column => typeof column.inferred?.unconvertible === 'number' && column.inferred.unconvertible > 0);
+        if (unconvertible.length > 0) {
+            notes.push(`Çevrilemeyen değer taşıyan sütunlar: ${unconvertible.map(column => `${String(column.slug)} (${String(column.inferred?.unconvertible)})`).join(', ')} — tipi ezmek ya da locale değiştirmek için import_plan gövdesinde karar verin.`);
+        }
+        return {
+            ...payload,
+            summary,
+            ...(notes.length > 0 ? { note: notes.join(' ') } : {})
+        };
+    }));
+    server.registerTool('import_plan', {
+        title: 'İçe aktarma planı (kuru koşu)',
+        description: "Analiz çıktısındaki seçimleri alır ve HİÇBİR SATIR YAZMADAN tüm dosyayı doğrular: tip dönüşümü, zorunluluk, benzersizlik, ilişki çözümü, upsert anahtarı. Yanıt planId + sayılar (eklenecek/güncellenecek/değişmeyen) + ilk 100 satır hatası + tam hata raporu dosyasıdır. Plan bir saat geçerlidir. Hataları düzeltmeden import_run çağırmayın.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            datasourceId: guid,
+            ...importChoicesShape
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, datasourceId, ...choices }) => {
+        assertNotProduction('import_plan', environment, config);
+        const problems = validateChoices(importChoicesSchema.parse(choices));
+        if (problems.length > 0) {
+            throw new PlatformApiError(`import_plan: seçimler eksik — ${problems.join(' ')}`, 400);
+        }
+        const payload = await platform.tenant('POST', project, `/entities/${datasourceId}/import/plan`, { environment, body: choices });
+        const plan = payload?.data;
+        const totals = plan?.totals;
+        const notes = [];
+        if (totals) {
+            notes.push(`${String(totals.insert ?? 0)} eklenecek · ${String(totals.update ?? 0)} güncellenecek · ${String(totals.unchanged ?? 0)} değişmeyecek · ${String(totals.errors ?? 0)} hata.`);
+        }
+        notes.push(plan?.requiresForce === true
+            ? "Hata oranı %50'nin üstünde: import_run bu planı yalnız force: true ile çalıştırır. Önce errors listesine bakın — çoğu zaman tek bir yanlış locale ya da sütun tipi bütün satırları düşürür."
+            : "import_run { planId, errorPolicy } ile başlatın; errorPolicy 'skip-rows' hatalı satırı atlar, 'all-or-nothing' hiçbir şey yazmaz.");
+        if (plan?.reportFileId)
+            notes.push(`Tam hata listesi dosyada: file_download { id: '${String(plan.reportFileId)}' }.`);
+        return { ...payload, note: notes.join(' ') };
+    }));
+    server.registerTool('import_run', {
+        title: 'İçe aktarmayı başlat',
+        description: "Kuru koşusu yapılmış planı arka planda çalıştırır ve 202 ile jobId döner. Tablolar kurulur, satırlar 1000'lik partilerle yazılır. Gateway BEKLEMEZ — bitişi import_status ile yoklayın. Yalnız development.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            datasourceId: guid,
+            planId: guid.describe('import_plan yanıtındaki planId; bir saat geçerlidir'),
+            errorPolicy: z.enum(importErrorPolicies).optional().describe("Planda verilenden farklıysa burada ezilir"),
+            rowActions: z.array(z.object({
+                row: z.number().int().min(1).describe('Dosyadaki 1 tabanlı satır numarası (başlık dahil)'),
+                action: z.enum(importRowActions)
+            })).optional().describe("Tek tek satır kararları: 'skip' satırı atlar, 'blank' çevrilemeyen hücreyi boş bırakır, 'apply-suggestion' plandaki öneriyi uygular"),
+            force: z.boolean().optional().describe("Hata oranı %50'nin üstündeyken zorunlu")
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, datasourceId, ...body }) => {
+        assertNotProduction('import_run', environment, config);
+        const payload = await platform.tenant('POST', project, `/entities/${datasourceId}/import/run`, { environment, body });
+        return {
+            ...payload,
+            note: 'İş arka planda başladı. import_status { jobId } ile izleyin; tamamlanınca result.tables sayıları ve reportFileId gelir. Gateway beklemez, siz tekrar çağırın.'
+        };
+    }));
+    server.registerTool('import_status', {
+        title: 'İçe aktarma işinin durumu',
+        description: "İş kaydını döner: planned → pending → validating → writing → completed | failed | cancelled; geri alınan içe aktarma undone olur. 'writing' durumunda progress.written/total ilerler; retryAfterSeconds yalnız süren işte gelir. Tamamlanmadan sonuç okumaya çalışmayın.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            jobId: guid.describe('import_run yanıtındaki jobId (plan ile aynı id)')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, jobId }) => {
+        const payload = await platform.tenant('GET', project, `/datajobs/${jobId}`, { environment });
+        const job = payload?.data;
+        const status = typeof job?.status === 'string' ? job.status : 'unknown';
+        const isImport = job?.kind === 'import';
+        if (status === 'completed') {
+            const report = job?.result?.reportFileId;
+            const notes = [report ? `İş tamamlandı. Atlanan satırların tam listesi dosyada: file_download { id: '${String(report)}' }.` : 'İş tamamlandı.'];
+            if (isImport) {
+                const undoAvailableUntil = typeof job?.undoAvailableUntil === 'string' ? job.undoAvailableUntil : undefined;
+                notes.push(undoAvailableUntil === undefined
+                    ? 'Bu iş geri alınamaz (anlık görüntü yok: mevcut tabloya yalnız ekleme yapıldı ya da 7 günlük pencere kapandı).'
+                    : Date.parse(undoAvailableUntil) > Date.now()
+                        ? `import_undo { jobId } ile ${undoAvailableUntil} tarihine kadar geri alınabilir.`
+                        : `Geri alma penceresi ${undoAvailableUntil} tarihinde kapandı; bu iş geri alınamaz.`);
+            }
+            return { ...payload, note: notes.join(' ') };
+        }
+        if (status === 'undone') {
+            return { ...payload, note: 'Bu içe aktarma geri alındı.' };
+        }
+        if (status === 'planned') {
+            return { ...payload, note: "Plan henüz çalıştırılmadı: import_run { datasourceId, planId } ile başlatın — planId bu jobId'dir ve plan bir saat geçerlidir." };
+        }
+        if (status === 'failed') {
+            return { ...payload, note: `İş düştü; \`error\` alanı nedeni söyler.${isImport ? ' Yazılmış partiler yerinde kalır; bugün geri alınamaz.' : ''}` };
+        }
+        if (status === 'cancelled') {
+            return { ...payload, note: `İş iptal edildi.${isImport ? ' Yazılmış partiler yerinde kalır; bugün geri alınamaz.' : ''}` };
+        }
+        return { ...payload, retryAfterSeconds: 5, note: `İş sürüyor (${status}). 5 saniye sonra import_status'ü tekrar çağırın; gateway beklemez.` };
+    }));
+    server.registerTool('import_history', {
+        title: 'Veri işleri geçmişi',
+        description: "Projedeki içe/dışa aktarma ve geri alma işlerini sayfalı listeler; order verilmezse en yeni iş önce gelir. Her satır kind, status, entityIds ve result taşır. kind: 'import' çalıştırılmamış planları (planned) da içerir; datasource filtresi yoktur. Geri alınabilir bir iş aramak (kind: 'import', status: 'completed', undoAvailableUntil geçmemiş) ya da düşen bir işin nedenini bulmak için kullanılır.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid.optional().describe('Yalnız bu tabloya dokunan işler'),
+            kind: z.enum(['import', 'export', 'undo']).optional(),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, order, isDescending, ...query }) => platform.tenant('GET', project, '/datajobs', {
+        environment,
+        query: { ...query, order: order ?? 'CreatedAt', isDescending: isDescending ?? (order === undefined ? true : undefined) }
+    })));
+    server.registerTool('import_undo', {
+        title: 'İçe aktarmayı geri al',
+        description: "Tamamlanmış ve undoAvailableUntil dolu bir içe aktarmayı geri alır: bu işte AÇILAN tablolar (başka tablo bağlı değilse, içindeki bütün satırlarla) ve ilişki için açılan referans satırları silinir; güncellenen satırların eşlenen sütunları önceki değerine döner. Mevcut tabloya EKLENEN satırlar silinmez, çakışma denetimi yoktur. 202 döner; geri alma ayrı bir iştir, import_status ile izlenir ve bitmeden aynı işe tekrar çağrılmaz. Yalnız development; kullanıcıya sormadan çağırmayın.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            jobId: guid.describe('Geri alınacak içe aktarma işinin id\'si (import_run ya da import_history\'den)')
+        },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, jobId }) => {
+        assertNotProduction('import_undo', environment, config);
+        const payload = await platform.tenant('POST', project, `/datajobs/${jobId}/undo`, { environment });
+        return {
+            ...payload,
+            note: "Geri alma işi başladı. import_status { jobId } ile izleyin — dönen jobId GERİ ALMA işinindir, kaynak işin değil; bitene kadar aynı işe import_undo'yu tekrar çağırmayın, ikinci bir geri alma işi açılır. Bittiğinde kaynak iş 'undone' olur: açılan tablolar ve referans satırları silinir, güncellenen satırlar önceki değerine döner, mevcut tabloya eklenen satırlar kalır. Geri alma işinin result.undoSkipped listesi başka tablo bağlı olduğu için silinemeyen tabloları sayar."
+        };
+    }));
+    server.registerTool('import_cancel', {
+        title: 'İçe aktarma işini iptal et',
+        description: "Bir içe aktarma işini durdurur: planned, pending ya da validating iş hemen ve kesin durur (yazmadan önce açılan tablo ve referans satırları kalır), writing iş o partinin sonunda durur. İptal ile tamamlanma yarışırsa önce yazan kazanır: iş bittiyse 409 döner ve completed kalır. Bitmiş işe (completed, failed, undone, cancelled) 409; tamamlanmış işi geri almak için import_undo. Yalnız development.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            jobId: guid.describe('İptal edilecek işin id\'si (import_run ya da import_history\'den)')
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, jobId }) => {
+        assertNotProduction('import_cancel', environment, config);
+        const payload = await platform.tenant('POST', project, `/datajobs/${jobId}/cancel`, { environment });
+        return {
+            ...payload,
+            note: "writing işte iptal parti sonunda etkili olur; import_status { jobId } ile progress.written'ın durduğunu görün. pending ya da validating iş hiç satır yazmadan durur. İptalden önce yazılan partiler yerinde kalır ve bugün geri alınamaz."
+        };
+    }));
+}

package/dist/tools/merges.js

@@ -0,0 +1,113 @@
+import { destructive, guid, pagingParams, readOnly, updates, writes } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const mergeView = z.enum(['summary', 'conflicts', 'full']).optional()
+    .describe("Planın ne kadarı dönsün: summary yalnız sayaçlar, conflicts yalnız çakışan kayıt/elemanlar (varsayılan), full her değişiklik");
+const mergeStatus = z.enum(['planning', 'planned', 'applying', 'applied', 'applied-with-drift', 'reverted', 'failed', 'discarded']).optional()
+    .describe("Duruma göre süz; 'applied' uygulanmış merge'ler, 'reverted' sonradan geri alınmış olanlar, 'discarded' bırakılmış planlar");
+const mergeTitle = z.string().trim().min(1).max(100)
+    .describe("İsteğin adı — git’teki merge request başlığı gibi: dal ne getiriyor. Kalıp: '<dal> → development: <amaç>'. ZORUNLUDUR (backend 2026-09-10’dan beri başlıksız isteği 400 ile reddeder) ve istekle birlikte kalıcıdır; geçmişte bu adla görünür.");
+const mergeDescription = z.string().trim().max(2000).optional()
+    .describe("Dalda ne değişti ve neden merge edilmeli — gözden geçirene yazılan gövde. Merge bunu ASLA ezmez; opsiyoneldir ama açıklamasız istekte değişiklik listesi okunacak tek şey kalır.");
+const resolution = z.object({
+    itemKey: z.string().min(1).describe("Plan kaydının anahtarı, ör. 'page:8f1c…' (merge_get çıktısındaki items[].key)"),
+    path: z.string().optional().describe("Eleman yolu, ör. 'components[elementId=btn_save].props[name=label].ref'; boş bırakılırsa o kaydın TÜM çakışmaları çözülür"),
+    choice: z.enum(['source', 'target']).describe("source = dal, target = development")
+});
+/**
+ * B-08 (2026-09-09 koşusu): `ResolveMergeConflictsCommandHandler` yanıtı
+ * `MergePlanDto.Map(..., view: Full)` ile kuruyor — yani her çözüm çağrısı planın TAMAMINI geri
+ * döndürüyor. Orta boy bir planda yanıt 68-121 KB'a çıkıp gateway yanıt sınırını aşıyor; çağrı
+ * hata gibi görünüyor, oysa çözüm uygulanmış oluyor (koşuda üç kez tekrarlandı). Gateway gövdeyi
+ * sayaçlara indirir; planın kendisini isteyen `merge_get` çağırır.
+ */
+export function resolveSummary(payload, planId, requested) {
+    const envelope = (payload && typeof payload === 'object' ? payload : {});
+    const plan = ((envelope.data && typeof envelope.data === 'object' ? envelope.data : envelope) ?? {});
+    const resolvedElements = (plan.items ?? []).reduce((total, item) => total + (item?.elements ?? []).filter(element => element?.resolution !== undefined && element?.resolution !== null).length, 0);
+    return {
+        planId: plan.id ?? planId,
+        ...(plan.status === undefined ? {} : { status: plan.status }),
+        ...(plan.summary === undefined ? {} : { summary: plan.summary }),
+        resolved: { requested, elements: resolvedElements },
+        note: "Yanıt ÖZETTİR — plan gövdesi kesildi. Planın kalan çakışmaları için merge_get { projectId, planId, view: 'conflicts' }; summary.unresolved 0 olduğunda merge_apply."
+    };
+}
+export function registerMergeTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('merge_plan', {
+        title: 'Merge planı oluştur',
+        description: "Bir dalı ebeveynine (development) merge etmek için üç yönlü diff planı ister. Hedef her zaman dalın ebeveynidir — production'a merge eden bir yol YOKTUR. title ZORUNLUDUR: isteğin adıdır ve geçmişte o adla durur. Asenkron: yanıt 202 döner, plan hemen dolu değildir. Projede açık bir plan varsa 400 döner; önce onu uygulayın ya da merge_discard ile bırakın.",
+        inputSchema: { projectId: guid, sourceEnvironmentId: guid, title: mergeTitle, description: mergeDescription },
+        annotations: writes
+    }, handle(config, async ({ projectId, sourceEnvironmentId, title, description }) => {
+        const payload = await platform.org('POST', `/merges/${projectId}`, { body: { sourceEnvironmentId, title, description } });
+        return {
+            ...(payload && typeof payload === 'object' ? payload : { data: payload }),
+            note: "plan asenkron hesaplanıyor; merge_get ile status=planned bekleyin"
+        };
+    }));
+    server.registerTool('merge_list', {
+        title: 'Merge geçmişini listele',
+        description: "Projenin merge planlarını en yeniden eskiye listeler — kim, ne zaman, hangi başlıkla merge etti. items[] bu uçta HER ZAMAN boş döner; bir planın değişiklik listesi için merge_get kullanın. status='applied' uygulanmış merge'leri verir (title, description, createdBy, appliedBy, appliedAt, summary sayaçları); 'discarded' bırakılmış, 'failed' başarısız planlardır. environmentId kaynak ya da hedef olarak o environment'ı kullanan planları süzer. Her satırda kind vardır (merge | revert); bir geri alma planında revertsPlanId geri alınan planı gösterir, o plan da reverted durumundadır.",
+        inputSchema: { projectId: guid, status: mergeStatus, environmentId: guid.optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ projectId, ...query }) => platform.org('GET', `/merges/${projectId}`, { query })));
+    server.registerTool('merge_get', {
+        title: 'Merge planını oku',
+        description: "Bir merge planını döner. items[] yalnız DEĞİŞEN kayıtları taşır; her kayıtta kind (add|update|delete|conflict) ve elements[] vardır. Çakışan elemanlarda base/source/target üç değeri birden gelir. dataRisk: true olan kalemde SEBEP dataRiskReasons[] içindedir: 'field-removed' (alan siliniyor), 'field-narrowed' (tip/nullable/unique daraltılıyor), 'not-null-without-default-on-populated-table' (hedefte satır varken varsayılansız NOT NULL alan ekleniyor — bu apply'ı DDL aşamasında düşürür, alanı nullable yapın ya da varsayılan verin). dataRisk bir UYARIDIR, apply'ı bloklamaz. derivedFromKey dolu olan kalem OTOMATİK ÜRETİLMİŞ bir kayıttır (varsayılan DTO); kaynağını (entity ya da query) çözdüğünüzde aynı yoldaki çakışması aynı tarafa KENDİLİĞİNDEN çözülür — ayrı ayrı ve zıt çözülemez. Uygulanmış planlarda title, description, createdBy ve appliedBy da gelir. kind=revert ise bu bir geri alma planıdır: revertsPlanId geri aldığı planı verir ve elements'te source merge ÖNCESİ, target ŞİMDİKİ değerdir. isStale: true ise plan alındığından beri DAL ya da development değişmiştir: items o değişikliği taşimaz ve merge_apply 409 döner — merge_refresh ile planı tazeleyin. elements[].isNoise: true olan eleman GÖSTERİM gürültüsüdür — kanvasın kendi durumu (workflow schema), DTO'dan türetilen şema (microservice schema.parameterScheme/returnScheme), sunucu yönetimli anahtar; merge gövdesinde KALIR ve uygulanır, yalnız okurken atlanır. Çakışan eleman asla işaretlenmez. items[].references[] o kalemin gövdesindeki guid'lerin karşılığıdır ({ id, name, module }): bir table step'in rule.entityId'si hangi tabloya, bir branch'in nextStepId'si hangi adıma, bir filtrenin fieldId'si hangi alana işaret ediyor — plan dışına çıkmadan okunur. items[].parentKey dolu olan kayıt başka bir kaydın çocuğudur (DTO çocukları, iç içe klasörler); ebeveyniyle birlikte okunur. items[].recordType kaydın modül içindeki türüdür — bir workflow kaydı 'workflow', 'automation' ya da 'middleware' olabilir ve modül üçüne de workflow der. items[].hiddenFields o kaydın GÖVDESİNDE okunmayacak anahtarlardır (aynı politika; eklenen/silinen kayıt tek eleman olarak geldiği için yolun değil anahtarın sorusudur).",
+        inputSchema: { projectId: guid, planId: guid, view: mergeView },
+        annotations: readOnly
+    }, handle(config, ({ projectId, planId, view }) => platform.org('GET', `/merges/${projectId}/${planId}?view=${view ?? 'conflicts'}`)));
+    server.registerTool('merge_resolve', {
+        title: 'Merge çakışmalarını çöz',
+        description: "Çakışan elemanlar için dal (source) ya da development (target) seçimini plana yazar. Yalnız status=planned iken çalışır. path boş bırakılırsa o kaydın tüm çakışmaları aynı tarafa çözülür. YANIT ÖZETTİR: { planId, status, summary, resolved } — platform planın tamamını döner ama gateway onu kesip yalnız sayaçları verir (orta boy planda tam gövde 68-121 KB'a çıkıyor ve yanıt sınırını aşıyordu; çağrı hata gibi görünürken çözüm UYGULANMIŞ oluyordu). Planın kendisini görmek için merge_get { planId, view:'conflicts' } çağırın; kalan çakışma sayısı summary.unresolved'dadır.",
+        inputSchema: { projectId: guid, planId: guid, resolutions: z.array(resolution).min(1) },
+        annotations: updates
+    }, handle(config, async ({ projectId, planId, resolutions }) => {
+        const payload = await platform.org('PUT', `/merges/${projectId}/${planId}/resolutions`, { body: { resolutions } });
+        return resolveSummary(payload, planId, resolutions.length);
+    }));
+    server.registerTool('merge_apply', {
+        title: 'Merge planını uygula',
+        description: "Planı tek transaction'da development'a uygular ve dalın şemasını düşürür. İsteğin adı zaten plan açılırken verilir; apply ayrı bir mesaj almaz. Asenkron: yanıt 202 döner. Çözülmemiş çakışma varsa 409 döner. PLAN BAYATSA DA 409 döner: plan alındıktan sonra DAL ya da development değiştiyse apply reddedilir — plan dalın o anki fotoğrafını taşır, uygulansaydı sonradan yapılan iş sessizce düşerdi. Çözümü merge_refresh'tir; yeni plan açmanız gerekmez.",
+        inputSchema: { projectId: guid, planId: guid },
+        annotations: writes
+    }, handle(config, async ({ projectId, planId }) => {
+        const payload = await platform.org('POST', `/merges/${projectId}/${planId}/apply`, { body: { projectId, planId } });
+        return {
+            ...(payload && typeof payload === 'object' ? payload : { data: payload }),
+            note: "merge asenkron koşuyor; merge_get ile status=applied (ya da applied-with-drift) bekleyin"
+        };
+    }));
+    server.registerTool('merge_refresh', {
+        title: 'Merge planını tazele',
+        description: "Açık bir planı dalın ve development'ın ŞU ANKİ hâline göre yeniden hesaplatır. İstek yerinde kalır: id'si, başlığı, açıklaması ve geçmişi korunur — yalnız değişiklik listesi yenilenir. KAYDEDİLMİŞ ÇAKIŞMA SEÇİMLERİ DÜŞER: yeni plan yeni elemanlar üretir, çözümler baştan verilir. Yalnız status=planned bir planda çalışır ve dal ready olmalıdır. Bayat bir planı (merge_get → isStale: true, ya da merge_apply 409) düzeltmenin yolu budur; merge_discard + merge_plan istemez. Asenkron: yanıt 202, plan planning durumundadır — merge_get ile planned bekleyin.",
+        inputSchema: { projectId: guid, planId: guid },
+        annotations: writes
+    }, handle(config, async ({ projectId, planId }) => {
+        const payload = await platform.org('POST', `/merges/${projectId}/${planId}/refresh`);
+        return {
+            ...(payload && typeof payload === 'object' ? payload : { data: payload }),
+            note: "plan yeniden hesaplanıyor; merge_get ile status=planned bekleyin — çakışma çözümleri baştan verilir"
+        };
+    }));
+    server.registerTool('merge_revert', {
+        title: "Uygulanmış merge'i geri al",
+        description: "Uygulanmış bir merge'i geri alan YENİ bir plan açar; kaynak plan silinmez, reverted olur ve geçmişte kalır. Yalnız status=applied|applied-with-drift ve kind=merge planlar geri alınabilir, pencere RevertWindowDays (varsayılan 7 gün) — dışında 400 döner. Ters plan kaynak plandaki her işlemi tersine çevirir: eklenen kayıt silinir, silinen geri gelir, değişen eski gövdesine döner. Merge'den SONRA elle değiştirilen kayıtlar conflict gelir ve orada source = merge öncesi değer, target = şimdiki değer demektir. Asenkron: yanıt 202, ters plan planning durumundadır.",
+        inputSchema: { projectId: guid, planId: guid },
+        annotations: writes
+    }, handle(config, async ({ projectId, planId }) => {
+        const payload = await platform.org('POST', `/merges/${projectId}/${planId}/revert`, { body: { projectId, planId } });
+        return {
+            ...(payload && typeof payload === 'object' ? payload : { data: payload }),
+            note: "ters plan hesaplanıyor; merge_get ile status=planned bekleyin, sonra merge_apply"
+        };
+    }));
+    server.registerTool('merge_discard', {
+        title: 'Merge planından vazgeç',
+        description: "Planı uygulamadan kapatır. Uygulanmakta olan (status=applying) bir plan bırakılamaz — 400 döner. Dal ve şeması olduğu gibi kalır.",
+        inputSchema: { projectId: guid, planId: guid },
+        annotations: destructive
+    }, handle(config, ({ projectId, planId }) => platform.org('DELETE', `/merges/${projectId}/${planId}`)));
+}

package/dist/tools/microfunctions.js

@@ -0,0 +1,155 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+import { unmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.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)");
+const behaviorParam = z.enum(['primitive', 'object', 'array']);
+const statusParam = z.enum(['draft', 'publishing', 'published', 'publish-failed']);
+const environmentVariablesParam = z.record(z.string())
+    .describe("Runtime'a geçen env değişkenleri; anahtar ^[A-Z_][A-Z0-9_]*$ ve toplam ≤ 4 KB (Lambda sınırı). Fonksiyon bunları Node'da process.env, Python'da os.environ üzerinden okur — SIR DEĞER KOYMAYIN: kayıt düz metin tutulur");
+// Create ve Update aynı gövdeyi taşır (Update yalnız id ekler): iki tool'un şeması tek yerde durur,
+// backend komutlarındaki alan çifti ayrışırsa `unmappedMembers` iki tool'da da aynı anda konuşur.
+const definitionInput = {
+    name: z.string().min(1).max(255).describe("Fonksiyon adı; tenant içinde BENZERSİZ. Slug bundan türetilir ve runtime fonksiyon adına girer (zf-{proje}-{ortam}-{slug}). SLUG DA BENZERSİZDİR: 'Sipariş' ile 'Siparis' farklı adlardır ama aynı slug'ı üretir ve ikincisi 409 alır"),
+    description: z.string().optional().describe('Fonksiyonun ne yaptığı; Studio listesinde görünür, çalışma zamanını etkilemez'),
+    language: z.enum(['node', 'python']).describe("Çalışma dili. Inline kaynakta dosya adı sabittir: node → function.js (exports.handler = async (args, context) => …), python → function.py (def handler(args, context))"),
+    provider: z.enum(['built-in', 'aws-lambda']).describe("'built-in' platformun kendi Fission kümesinde koşar ve runtime hesabı İSTEMEZ (runtimeId boş kalır); 'aws-lambda' müşterinin kendi hesabında koşar ve runtimeId ZORUNLUDUR. 'azure-functions' enum'da tanımlı ama v1'de reddedilir (Faz 2)"),
+    runtimeId: guid.optional().describe("AWS Lambda hesabı (microfunction_runtime_list). provider 'built-in' ise VERİLMEZ; 'aws-lambda' ise zorunlu ve hesabın provider'ı fonksiyonunkiyle aynı olmalı"),
+    sourceKind: z.enum(['inline', 'archive']).describe("'inline' ⇒ code zorunlu (≤ 512 KB, standart kütüphane; bağımlılık YOK); 'archive' ⇒ önce kayıt açılır, zip Studio'dan yüklenir (MCP'de zip yükleme yok — Faz 2) ve entrypoint 'modül.fonksiyon' olarak verilir"),
+    code: z.string().optional().describe("Inline kaynak kodu. Sözleşme: tek bir handler dışa aktarılır, args çağrı argümanları, context SALT OKUNUR anlık görüntüdür (input/variables/steps/user/request/language/project/environment). Yazma yalnız dönüş değeriyle olur. Ayrıntı: platform_guide('microfunction')"),
+    entrypoint: z.string().optional().describe("Zip kaynağında 'modül.fonksiyon' (ör. 'handlers/sum.handler'). Inline kaynakta gateway'in de platformun da beklediği sabit 'function.handler'dır — vermeyin"),
+    parameterDtoId: guid.optional().describe("Çağrı argümanlarının sözleşmesi (DataTransferObject). Workflow step'i ifadeyi bu şemaya göre yazar; boşsa args = {} gider"),
+    parameterBehavior: behaviorParam.optional().describe('parameterDtoId verildiyse zorunlu: primitive | object | array'),
+    returnDtoId: guid.optional().describe('Dönüş sözleşmesi; step çıktısının şeması bundan üretilir'),
+    returnBehavior: behaviorParam.optional().describe('returnDtoId verildiyse zorunlu: primitive | object | array'),
+    timeoutSeconds: z.number().int().min(1).max(900).optional().describe("Fonksiyon bütçesi; varsayılan 30. Built-In üst sınırı 300, Lambda 900. Bütçe dolarsa çağrı MicrofunctionInvocationTimeoutException ile step'in fail dalına düşer"),
+    memoryMb: z.number().int().min(128).max(3008).optional().describe("Varsayılan 256. Built-In'de yalnız kaydedilir (küme environment limiti geçerlidir); Lambda'da gerçekten uygulanır"),
+    environmentVariables: environmentVariablesParam.optional(),
+    publish: z.boolean().optional().describe("true: kayıt açıldıktan/güncellendikten sonra aynı çağrıda yayın istenir ('Kaydet ve yayınla'). Yayın ASENKRONDUR — çağrı status: 'publishing' döner; sonucu microfunction_get ile izleyin (published | publish-failed + publishError)")
+};
+const runtimeInput = {
+    name: z.string().min(1).max(255).describe('Hesap adı; benzersiz'),
+    provider: z.literal('aws-lambda').optional().describe("v1'de yalnız 'aws-lambda' kabul edilir; gönderilmezse gateway onu koyar"),
+    region: z.string().min(1).describe("AWS bölge kodu, ör. 'eu-central-1'"),
+    accessKeyId: z.string().min(1).describe('AWS access key id'),
+    secretAccessKey: z.string().min(1).describe("AWS secret access key. Kayıt düz metin tutulur; platform DTO'da maskeler (**** + son 4), gateway bu tool'ların yanıtında değeri tümüyle '***' yapar"),
+    roleArn: z.string().optional().describe("Lambda execution rolü: arn:aws:iam::<12 hane>:role/<ad>. Rolü müşteri oluşturur; fonksiyon bu rolle koşar")
+};
+export function registerMicrofunctionTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('microfunction_list', {
+        title: 'Microfunction listele',
+        description: "Proje kapsamındaki microfunction'ları listeler. Workflow step'i kurmadan ÖNCE bunu status: 'published' ile çağırın: step yalnız yayındaki kaydı koşturur, taslak seçilirse koşum fail dalına düşer (WF-MF-001). Süzgeç ve sayfalama SUNUCUDA uygulanır: searchTerm ad/slug/açıklama içinde arar, sayfa boyu verilmezse gateway 200 gönderir (platform varsayılanı 10'dur).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            status: statusParam.optional().describe("Durum süzgeci; step editörü için 'published'"),
+            searchTerm: z.string().optional().describe('Ad, slug ve açıklamada geçen metin; büyük/küçük harf duyarsız'),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, status, searchTerm, pageIndex, pageLength, order, isDescending }) => platform.tenant('GET', project, '/microfunctions', {
+        environment,
+        query: { status, searchTerm, pageIndex: pageIndex ?? 0, pageLength: pageLength ?? 200, order, isDescending }
+    })));
+    server.registerTool('microfunction_get', {
+        title: 'Microfunction getir',
+        description: "Tek bir microfunction'ın tanımını ve yayın durumunu getirir: status, revision/publishedRevision, hasUnpublishedChanges (kayıt yayında ama üstüne yazılmış), publishError, parameterScheme/returnScheme. Yayın asenkron olduğu için 'publishing' durumunda birkaç saniye arayla tekrar çağırın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microfunctions/${id}`, { environment })));
+    server.registerTool('microfunction_create', {
+        title: 'Microfunction tanımla',
+        description: "Yeni microfunction kaydeder. Kayıt DRAFT doğar; yayına almadan hiçbir workflow step'i onu koşturamaz (publish: true ile aynı çağrıda yayın isteyebilirsiniz). Yayın adımı kodu runtime'a kurar ve bir 'probe' çağrısıyla duman testi yapar: sözdizimi/import hatası yayın anında publish-failed olur, koşumda değil. Protokol ve sınırlar: platform_guide('microfunction'). " + constraintSummary('CreateMicrofunctionCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, ...definitionInput, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, policyOverride, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunction', body, { operation: 'create' }, policyOverride));
+        const drift = unmappedMembers('CreateMicrofunctionCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('POST', project, '/microfunctions', { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_update', {
+        title: 'Microfunction güncelle',
+        description: "Microfunction'ın TAMAMINI değiştirir (PUT — değiştirmediğiniz alanları da gönderin; önce microfunction_get). Her güncelleme revision'ı artırır: yayındaki kayıt güncellenirse runtime ESKİ sürümü koşmaya devam eder ve kayıt hasUnpublishedChanges: true olur — yeni kodu canlıya almak için publish: true verin ya da microfunction_publish çağırın. PROVIDER YAYINDAYKEN DEĞİŞMEZ: bir kez yayınlanmış kaydın provider'ını değiştiren PUT 400 döner (MicrofunctionProviderChangeNotAllowedException) — kaydı silip yeniden oluşturun. " + constraintSummary('UpdateMicrofunctionCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...definitionInput, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, policyOverride, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunction', body, { operation: 'update' }, policyOverride));
+        const drift = unmappedMembers('UpdateMicrofunctionCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('PUT', project, `/microfunctions/${id}`, { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_publish', {
+        title: 'Microfunction yayınla',
+        description: "Kaydı runtime'a kurar. Çağrı 202 ile hemen döner ve kayıt 'publishing' olur; sonucu microfunction_get ile izleyin — 'published' (publishedReference: Fission fonksiyon adı ya da Lambda ARN) ya da 'publish-failed' (publishError). Zaten yayınlanmakta olan bir kayıt için çağrı 400 döner.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: updates
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microfunctions/${id}/publish`, { environment })));
+    server.registerTool('microfunction_delete', {
+        title: 'Microfunction sil',
+        description: "Microfunction'ı siler ve runtime'daki fonksiyonu kaldırır. Bir workflow step'i kaydı kullanıyorsa 400 ile reddedilir (CantDeleteUsedMicrofunctionException) ve mesaj çağıran akışın adını taşır — önce step'i kaldırın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/microfunctions/${id}`, { environment })));
+    server.registerTool('microfunction_invoke', {
+        title: 'Microfunction çağır',
+        description: "Yayındaki fonksiyonu GERÇEK runtime'da koşturur ve zarfı döner: { ok, output, error, logs, durationMs }. Test çağrısıdır ama rollback YOKTUR — fonksiyon dış dünyaya ne yaptıysa kalır. ok:false ise error.type/message/stack okunur; aynı hata workflow'da step'i fail dalına düşürür. Taslak kayıtta çağrı MicrofunctionNotPublishedException ile döner. Kaydetmeden koşma yolu yoktur: önce microfunction_update + publish.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            args: z.record(z.unknown()).optional().describe("Fonksiyona giden argüman nesnesi (handler'ın ilk parametresi); parameterDtoId varsa o şemaya uymalı"),
+            preview: z.boolean().optional().describe("true: shim logları (console.log/print) zarfın logs alanında döner. false/boş: logs boş gelir — hata ayıklarken açın")
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, args, preview }) => platform.tenant('POST', project, `/microfunctions/${id}/invoke`, { environment, body: { args, preview } })));
+    server.registerTool('microfunction_runtime_list', {
+        title: 'Microfunction runtime hesaplarını listele',
+        description: "Bulut runtime hesaplarını (v1: AWS Lambda) listeler; secretAccessKey maskeli döner. Built-In fonksiyonların runtime kaydı YOKTUR — liste boşsa yalnız provider: 'built-in' fonksiyon tanımlayabilirsiniz.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/microfunction-runtimes', { environment })));
+    server.registerTool('microfunction_runtime_get', {
+        title: 'Microfunction runtime hesabını getir',
+        description: 'Tek bir runtime hesabını getirir (secretAccessKey maskeli).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microfunction-runtimes/${id}`, { environment })));
+    server.registerTool('microfunction_runtime_create', {
+        title: 'Microfunction runtime hesabı tanımla',
+        description: "AWS Lambda hesabı kaydeder: bölge + erişim anahtarları + Lambda execution rolü (roleArn). Kimlik bilgileri düz metin tutulur (Datasource emsali) — dar yetkili bir IAM kullanıcısı verin. Kaydettikten sonra microfunction_runtime_test_connection ile doğrulayın. " + constraintSummary('CreateMicrofunctionRuntimeCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, ...runtimeInput, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, policyOverride, ...input }) => {
+        const body = { ...input, provider: input.provider ?? 'aws-lambda' };
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunctionRuntime', body, { operation: 'create' }, policyOverride));
+        const drift = unmappedMembers('CreateMicrofunctionRuntimeCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('POST', project, '/microfunction-runtimes', { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_runtime_update', {
+        title: 'Microfunction runtime hesabını güncelle',
+        description: 'Runtime hesabının tamamını değiştirir (PUT). secretAccessKey maskeli okunduğu için güncellemede GERÇEK değeri yeniden gönderin — maskeyi geri yazmayın. ' + constraintSummary('UpdateMicrofunctionRuntimeCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...runtimeInput, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, policyOverride, ...input }) => {
+        const body = { ...input, provider: input.provider ?? 'aws-lambda' };
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunctionRuntime', body, { operation: 'update' }, policyOverride));
+        const drift = unmappedMembers('UpdateMicrofunctionRuntimeCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('PUT', project, `/microfunction-runtimes/${id}`, { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_runtime_delete', {
+        title: 'Microfunction runtime hesabını sil',
+        description: 'Runtime hesabını siler. Bir microfunction hesabı kullanıyorsa 400 ile reddedilir (CantDeleteUsedMicrofunctionRuntimeException).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/microfunction-runtimes/${id}`, { environment })));
+    server.registerTool('microfunction_runtime_test_connection', {
+        title: 'Microfunction runtime bağlantısını test et',
+        description: "Kayıtlı hesabın kimlik bilgilerini gerçek bulut ucunda dener (Lambda: ListFunctions). Hata 400 olarak döner ve mesaj AWS'in kendi cümlesidir — yayın denemeden önce buradan doğrulayın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: updates
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microfunction-runtimes/${id}/test-connection`, { environment })));
+}

package/dist/tools/microservices.js

@@ -80,7 +80,8 @@ const executeInput = {
     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."),
     asUser: asUserParam,
     cookies: cookiesParam,
-    language: languageParam
+    language: languageParam,
+    expectFailure: z.boolean().optional().describe("true: bu çağrıda bir hata dönmesi BEKLENİYOR (kasıtlı negatif test — yanlış parola, yetkisiz erişim, geçersiz gövde). Yanıt yine httpStatus'u/hatayı taşır, ama ölçüm aracı bu satırı plansız hata saymaz (page_screenshot'taki expectFailure deseniyle aynı).")
 };
 /**
  * `anonymous` ile kimlik birlikte verilemez: biri kimliksiz isteği, diğeri belirli bir üyenin
@@ -382,8 +383,46 @@ export function registerMicroserviceTools(server, platform) {
     }));
     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 },
+        description: 'Zamanlanmış (job tipli) microservice\'in çalışma geçmişini listeler. status ile yalnız running | completed | failed koşular süzülür; order TriggeredAt | CompletedAt | ExecutionStatus | DurationMs.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            status: z.enum(['running', 'completed', 'failed']).optional().describe('Yalnız bu durumdaki koşular'),
+            ...pagingParams
+        },
         annotations: readOnly
     }, handle(config, ({ project, environment, id, ...query }) => platform.tenant('GET', project, `/microservices/${id}/job-history`, { environment, query })));
+    server.registerTool('microservice_schedule_get', {
+        title: 'Zamanlama durumu',
+        description: 'Zamanlanmış (schedule-job) microservice\'in canlı zamanlama durumunu döner: state (scheduled | paused | notScheduled | error | ended), isRunning, nextFireTimeUtc, previousFireTimeUtc, sıradaki 5 koşu (upcomingFireTimesUtc), cron + timeZoneId, serverTimeUtc ve son koşunun özeti (lastExecution). "Bir sonraki sefer ne zaman koşacak?" sorusunu cron\'u yorumlamadan buradan cevaplayın. paused iken nextFireTimeUtc null ve upcoming boştur. notScheduled: kayıt var ama zamanlayıcıda trigger yok — en geç 5 dk içinde uzlaştırma kurar ya da servisi kaydedin (microservice_update). ended: tanımın sonraki koşusu yok (once geçti, end on/after doldu). schedule alanı tanımın kendisidir. Schedule tipli olmayan servis 400 döner.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microservices/${id}/schedule`, { environment })));
+    server.registerTool('microservice_schedule_forecast', {
+        title: 'Zamanlama öngörüsü',
+        description: 'Bir zamanlama tanımını (typeParameters.schedule biçimi) KAYDETMEDEN doğrular ve sıradaki 5 koşuyu UTC olarak döner: { isValid, errors[{property,message}], upcomingFireTimesUtc[] }. microservice_create/update öncesi tanımın beklenen saatlerde koştuğunu buradan görün; alan listesi için platform_guide(\'microservice\') §Zamanlanmış iş.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            schedule: z.record(z.unknown()).describe('ScheduleDefinition: mode, timeZoneId, startAt, every, unit, timeOfDay, daysOfWeek, daysOfMonth, cronExpression, end')
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, schedule }) => platform.tenant('POST', project, '/microservices/schedule/preview', { environment, body: { schedule } })));
+    server.registerTool('microservice_schedule_control', {
+        title: 'Zamanlamayı yönet',
+        description: 'Zamanlanmış microservice\'i duraklatır (pause), sürdürür (resume) ya da cron\'u beklemeden bir kez koşturur (trigger). pause/resume yalnız zamanlayıcıdaki durumu değiştirir, tanımı değil; duraklatma cron güncellemesi ve deployment senkronundan sonra da korunur. resume: duraklatılmışken bir koşu kaçırıldıysa iş bir kez hemen koşar. trigger KUYRUĞA ALIR, sonucu beklemez: deployment ya da template kurulumu sürüyorsa koşu veto edilir ve geçmişe hiç düşmez — sonucu microservice_job_history ile doğrulayın. Zamanlayıcıda kaydı olmayan iş 400 (ScheduleJobNotRegisteredException) döner. Production ortamında üç eylem de 400 CantWriteInProductionException ile reddedilir; trigger ayrıca deployment/template kurulumu sürerken reddedilir.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            action: z.enum(['pause', 'resume', 'trigger']).describe('pause | resume | trigger')
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, action }) => {
+        await platform.tenant('POST', project, `/microservices/${id}/schedule/${action}`, { environment });
+        return action === 'trigger'
+            ? { action, accepted: true, note: 'Kuyruğa alındı; koşuyu microservice_job_history ile doğrulayın.' }
+            : { action, accepted: true, note: 'Güncel durum için microservice_schedule_get.' };
+    }));
 }