@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/knowledge/outlines.js

@@ -1,3 +1,4 @@
+import { functionSignature } from './functionGuards.js';
 function asArray(value) {
     return Array.isArray(value) ? value.filter((entry) => Boolean(entry) && typeof entry === 'object') : [];
 }
@@ -62,6 +63,8 @@ export function entityOutline(definition) {
         slug: definition.slug,
         name: definition.name,
         datasourceId: definition.datasourceId,
+        localizationEntityId: definition.localizationEntityId ?? null,
+        localizationParentId: definition.localizationParentId ?? null,
         fieldCount: asArray(definition.fields).length,
         fields: asArray(definition.fields).map(field => ({
             id: field.id,
@@ -73,10 +76,116 @@ export function entityOutline(definition) {
             relationId: field.relationId ?? null,
             isLocalized: Boolean(field.isLocalized)
         })),
+        indexCount: asArray(definition.indexes).length,
+        // Index'ler alanlardan çok daha az sayıdadır; tam projeksiyon outline'ı şişirmez ve yazılan
+        // index'in kanıtı ayrı bir tur istemez (B-45'in `entity_get`/`entity_create` ayağı).
+        ...(asArray(definition.indexes).length > 0
+            ? {
+                indexes: asArray(definition.indexes).map(index => ({
+                    id: index.id,
+                    name: index.name,
+                    unique: Boolean(index.unique),
+                    fieldIds: Array.isArray(index.fieldIds) ? index.fieldIds : []
+                }))
+            }
+            : {}),
         view: 'outline',
         hint: "Bir alanın tam gövdesi için view:'part', part:'fields[slug=<slug>]'; değişiklik için entity_patch. isLocalized alanlar için platform_guide('entity') §'Çoklu dilli alan'."
     };
 }
+const identityKeys = ['id', 'slug', 'name', 'elementId', 'stepId'];
+/**
+ * Eklenen öğeyi FİNAL gövdede kimliğinden bulur. Konumsal ("dizinin son elemanı") arama
+ * platform diziye kendi öğesini eklediğinde yanlış kaydı gösterir: audit trail açık bir
+ * entity'ye alan eklendiğinde platform `fields`in sonuna dört `sys_*` alanı ekler ve rapor
+ * eklenen alan yerine `sys_updated_user_id`'yi gösteriyordu (ölçüldü 2026-09-08).
+ */
+function appendedPosition(section, value) {
+    if (!value || typeof value !== 'object')
+        return -1;
+    const source = value;
+    for (const key of identityKeys) {
+        const wanted = source[key];
+        if (wanted === undefined || wanted === null || wanted === '')
+            continue;
+        const position = section.findIndex(item => Boolean(item) && typeof item === 'object' && item[key] === wanted);
+        if (position >= 0)
+            return position;
+    }
+    return -1;
+}
+/**
+ * Patch'in DOKUNDUĞU bölümleri kayıttan çıkarır (S-8 · P2-1).
+ *
+ * `entity_patch` yanıtı bir outline'dır ve outline `indexes` taşımıyordu: 2026-09-06 koşusunda
+ * iki index yazıldı, "yazdım" demenin kanıtı yanıtta olmadığı için her entity için ayrı bir
+ * `entity_get(view:'part', part:'indexes[0]')` turu atıldı. Keşif çağrısı oranı o koşuda %30.1'di.
+ *
+ * Outline'ın kısa kalma amacı korunur: TAM gövde değil, yalnız yamanın adreslediği bölüm döner —
+ * dizide de yalnız dokunulan eleman. Yollar `resolvePatchOperations`'tan geçmiş, yani indekse
+ * çevrilmiş olmalıdır; `-` (dizi sonu) eklenen son elemana çözülür.
+ */
+export function patchedSections(document, operations) {
+    const explicit = new Map();
+    const appends = new Map();
+    const whole = new Set();
+    for (const operation of operations) {
+        const path = typeof operation.path === 'string' ? operation.path : '';
+        if (!path.startsWith('/'))
+            continue;
+        const [key, index] = path.split('/').slice(1);
+        if (!key || !Object.hasOwn(document, key))
+            continue;
+        if (!Array.isArray(document[key]) || index === undefined) {
+            whole.add(key);
+            continue;
+        }
+        // Dizi sonu (`-`) yolu FİNAL gövdede tek bir indekse çözülemez: aynı çağrıda iki `add`
+        // varsa ikisi de son elemanı gösterir ve rapor bir tanesini yutardı (ölçüldü 2026-09-06,
+        // gerçek uçta: iki index eklendi, yanıt birini gösterdi). Eklenen gövde saklanır ve önce
+        // KİMLİKTEN aranır; kimlik tutmazsa son N eleman alınır.
+        if (index === '-') {
+            appends.set(key, [...(appends.get(key) ?? []), operation.value]);
+            continue;
+        }
+        const position = Number(index);
+        if (!Number.isInteger(position) || position < 0)
+            continue;
+        const positions = explicit.get(key) ?? new Set();
+        positions.add(position);
+        explicit.set(key, positions);
+    }
+    const touched = {};
+    for (const key of whole)
+        touched[key] = document[key];
+    for (const key of new Set([...explicit.keys(), ...appends.keys()])) {
+        if (whole.has(key))
+            continue;
+        const section = document[key];
+        const wanted = new Set();
+        for (const position of explicit.get(key) ?? []) {
+            if (position < section.length)
+                wanted.add(position);
+        }
+        let unresolved = 0;
+        for (const value of appends.get(key) ?? []) {
+            const position = appendedPosition(section, value);
+            if (position >= 0)
+                wanted.add(position);
+            else
+                unresolved++;
+        }
+        for (let step = 0; step < unresolved; step++) {
+            const position = section.length - 1 - step;
+            if (position >= 0)
+                wanted.add(position);
+        }
+        if (wanted.size === 0)
+            continue;
+        touched[key] = [...wanted].sort((left, right) => left - right).map(position => section[position]);
+    }
+    return touched;
+}
 const segmentPattern = /^(\w+)(?:\[(?:(\d+)|(\w+)=([^\]]+))\])?$/;
 export function resolvePart(definition, part) {
     let current = definition;
@@ -111,7 +220,7 @@ function unescapePointer(segment) {
  * `*_get`'in `part` sözdizimindeki seçiciyi (`steps[id=…]`, `fields[slug=…]`) patch yollarında da
  * kabul edip indekse çeviriyoruz; çözülemeyen seçici, gövde platforma GİTMEDEN hata verir.
  */
-export function resolvePatchPointer(document, path) {
+export function resolvePatchPointer(document, path, readTool = 'workflow_get', op = '') {
     if (!path.startsWith('/'))
         throw new Error(`JSON Patch yolu '/' ile başlamalı: '${path}'`);
     const segments = path.split('/').slice(1);
@@ -131,11 +240,21 @@ export function resolvePatchPointer(document, path) {
         const [, key, field, value] = match;
         const collection = current && typeof current === 'object' ? current[key] : undefined;
         if (!Array.isArray(collection)) {
-            throw new Error(`Patch yolu çözülemedi: '${path}' — '${key}' bir dizi değil. Mevcut yapıyı workflow_get view:'outline' ile okuyun.`);
+            throw new Error(`Patch yolu çözülemedi: '${path}' — '${key}' bir dizi değil. Mevcut yapıyı ${readTool} view:'outline' ile okuyun.`);
         }
         const index = collection.findIndex(entry => entry && typeof entry === 'object' && String(entry[field]) === value);
         if (index === -1) {
-            throw new Error(`Patch yolu çözülemedi: '${path}' — '${key}' dizisinde ${field}='${value}' yok. Mevcut id/ad değerlerini workflow_get view:'outline' ile okuyun.`);
+            const available = collection
+                .map(entry => entry && typeof entry === 'object' ? entry[field] : undefined)
+                .filter(entry => entry !== undefined && entry !== null)
+                .map(entry => `'${String(entry)}'`);
+            // Seçici VAR OLAN bir öğeyi adresler; yeni öğe eklemenin yolu dizi sonu (`-`) segmentidir.
+            // 2026-09-06 koşusunda ajan eksik bir iteratee'yi `add` ile eklemeye çalıştı, mesaj yalnız
+            // "yok" dedi ve ajan diziyi 13 girdiyle baştan yazmak zorunda kaldı (S-5 · P0-2 Step 6).
+            const addHint = op === 'add'
+                ? ` EKLEMEK istiyorsanız seçici değil dizi sonu yolunu kullanın: '${path.slice(0, path.indexOf(`${key}[`) + key.length)}/-' — seçici yalnız VAR OLAN öğeyi adresler.`
+                : '';
+            throw new Error(`Patch yolu çözülemedi: '${path}' — '${key}' dizisinde ${field}='${value}' yok. Mevcut değerler: ${available.length > 0 ? available.join(', ') : '(hiç)'}.${addHint} Tam listeyi ${readTool} view:'outline' ile okuyun.`);
         }
         resolved.push(key, String(index));
         current = collection[index];
@@ -145,24 +264,30 @@ export function resolvePatchPointer(document, path) {
     return rewritten ? { path: resolvedPath, note: `${path} → ${resolvedPath}` } : { path: resolvedPath };
 }
 /**
- * Yanıtın `applied: N` demekle yetinmemesi için: her op'un hangi step'e indiğini adıyla söyler.
+ * Yanıtın `applied: N` demekle yetinmemesi için: her op'un hangi öğeye indiğini adıyla söyler.
+ * Seçiciyle yazılan yol indekse çevrildiği için, indeksin hangi kayda denk geldiğini görmek
+ * sessiz veri bozulmasını önleyen tek sinyaldir (entity'de alan sırası değişebilir).
  */
 export function describePatchTarget(document, path) {
-    const match = /^\/steps\/(\d+)(\/.*)?$/.exec(path);
+    const match = /^\/(steps|fields|indexes)\/(\d+)(\/.*)?$/.exec(path);
     if (!match)
         return path;
-    const step = asArray(document.steps)[Number(match[1])];
-    return step
-        ? `${path} → '${String(step.name ?? step.id ?? '?')}' (${String(step.type ?? '?')}, id ${String(step.id ?? '?')})`
-        : `${path} → (dizide ${match[1]}. eleman YOK)`;
+    const collection = asArray(document[match[1]]);
+    const entry = collection[Number(match[2])];
+    if (!entry)
+        return `${path} → (dizide ${match[2]}. eleman YOK)`;
+    const label = String(entry.name ?? entry.slug ?? entry.id ?? '?');
+    const kind = entry.type ?? entry.dbType;
+    return `${path} → '${label}'${kind ? ` (${String(kind)}` + `, id ${String(entry.id ?? '?')})` : `, id ${String(entry.id ?? '?')}`}`;
 }
-export function resolvePatchOperations(document, operations) {
+export function resolvePatchOperations(document, operations, readTool = 'workflow_get') {
     const notes = [];
     const targets = [];
     const resolved = operations.map(operation => {
         const path = typeof operation.path === 'string' ? operation.path : '';
-        const outcome = resolvePatchPointer(document, path);
-        const from = typeof operation.from === 'string' ? resolvePatchPointer(document, operation.from) : undefined;
+        const op = typeof operation.op === 'string' ? operation.op : '';
+        const outcome = resolvePatchPointer(document, path, readTool, op);
+        const from = typeof operation.from === 'string' ? resolvePatchPointer(document, operation.from, readTool, op) : undefined;
         if (outcome.note)
             notes.push(outcome.note);
         if (from?.note)
@@ -172,3 +297,33 @@ export function resolvePatchOperations(document, operations) {
     });
     return { operations: resolved, notes, targets };
 }
+/**
+ * Fonksiyon özeti (G-07): kaynak, ad, kapsam, imza, parametre listesi, gövde satır sayısı —
+ * gövdenin kendisi TAŞINMAZ (liste yanıtı MAX_RESPONSE_BYTES'ı şişirmesin). `function_patch`
+ * AÇILMADI: fonksiyonda tek büyük alan gövdedir ve gövde bütün olarak yazılır; kısmi güncellemeyi
+ * `function_update` mevcut kaydı okuyup eksik alanları doldurarak sağlar.
+ */
+export function functionOutline(definition) {
+    const parameters = asArray(definition.parameters);
+    const source = definition.source === 'workflow' ? 'workflow' : 'studio';
+    return {
+        id: definition.id,
+        source,
+        name: definition.name,
+        applicationId: definition.applicationId ?? null,
+        scope: source === 'workflow' ? null : (definition.scope ?? 'application'),
+        pageId: definition.pageId ?? null,
+        isAsync: definition.isAsync === true,
+        signature: functionSignature(definition),
+        parameters: parameters.map(parameter => ({
+            name: parameter.name,
+            type: parameter.type ?? 'any',
+            required: parameter.required === true,
+            defaultValue: parameter.defaultValue ?? null,
+            description: parameter.description ?? null
+        })),
+        description: definition.description ?? null,
+        bodyLines: typeof definition.body === 'string' && definition.body.length > 0 ? definition.body.split('\n').length : 0,
+        view: 'outline'
+    };
+}

package/dist/knowledge/policy.js

@@ -11,6 +11,19 @@ export class PolicyBlockError extends Error {
         this.name = 'PolicyBlockError';
     }
 }
+/**
+ * `POLICY=warn` ve `policyOverride` kaçışları kuralın nereden geldiğine bakmaz: senkron
+ * `check`'lerden gelen bulgular da, platformdan okunarak üretilen bulgular da (WF-MF-001'in
+ * yayın durumu ön-denetimi) aynı kapıdan geçer. İki yerde iki farklı indirgeme olursa bir
+ * bulgu `policyOverride: true` ile de isteği durdurur ve kaçış yalanı çıkar.
+ */
+export function applyPolicyMode(config, findings, policyOverride = false) {
+    if (config.policyMode !== 'warn' && !policyOverride)
+        return findings;
+    return findings.map(finding => finding.severity === 'block'
+        ? { ...finding, severity: 'warn', message: `${finding.message} [block → warn: ${policyOverride ? 'policyOverride' : 'POLICY=warn'}]` }
+        : finding);
+}
 export function evaluatePolicy(config, rules, module, definition, context, policyOverride = false) {
     if (config.policyMode === 'off') {
         logStep('politika', `${module}/${context.operation} · POLICY=off — lint çalıştırılmadı`);
@@ -18,11 +31,7 @@ export function evaluatePolicy(config, rules, module, definition, context, polic
     }
     const applicable = rules.filter(rule => rule.module === module && rule.appliesTo.includes(context.operation));
     const raw = applicable.flatMap(rule => rule.check(definition, context));
-    const findings = config.policyMode === 'warn' || policyOverride
-        ? raw.map(finding => finding.severity === 'block'
-            ? { ...finding, severity: 'warn', message: `${finding.message} [block → warn: ${policyOverride ? 'policyOverride' : 'POLICY=warn'}]` }
-            : finding)
-        : raw;
+    const findings = applyPolicyMode(config, raw, policyOverride);
     logStep('politika', `${module}/${context.operation}${context.workflowKind ? ` (${context.workflowKind})` : ''} · ${applicable.length} kural denendi · ${findings.length === 0 ? 'bulgu yok' : `${findings.length} bulgu`}${policyOverride ? ' · policyOverride açık' : ''}`, findings.map(finding => `[${finding.ruleId}] ${finding.severity}: ${finding.message}`));
     return findings;
 }

package/dist/knowledge/propTypes.js

@@ -0,0 +1,80 @@
+import { findNode } from '../tools/screens.js';
+/**
+ * Prop değerinin `type` alanı üç değer alır ve her biri taşıyıcısı farklıdır.
+ *
+ * Platformun kendi micro-op applier'ı `replace_prop`'ta gönderilen ham değeri HER ZAMAN `Static`
+ * (ifade verilmişse `Code`) Prop'una sarar (`PageSchemaMicroOpApplier.cs:77`), yani kurulu bir
+ * etiketi çeviriye bağlamanın platform tarafında bir yolu yoktur. Bu op o boşluğu kapatır:
+ * şemayı okur, prop'un TİPİNİ yerinde değiştirir, gövdeyi tam yazar.
+ *
+ * Alternatifi `remove_component` + `add_component`'tı ve pahalıydı: 2026-09-06 koşusunda on bir
+ * etiket o yolla yeniden kuruldu, o düğümlere yazan DOKUZ setter iteratee'si platform tarafından
+ * sessizce silindi ve üç KPI kartı boş kaldı (S-5/G-2).
+ *
+ * Taşıyıcı: `static` değeri `data`'da; `code` ve `translation` ifadeyi/anahtarı `ref`'te taşır —
+ * runtime `data`'yı her turda çözümlenmiş değerle ezer, o yüzden anahtar yalnız `ref`'te yaşar
+ * (`platform_guide('translation')`).
+ */
+export const PROP_TYPE_CARRIER = { static: 'data', code: 'ref', translation: 'ref' };
+export const SET_PROP_TYPE_OP = 'set_prop_type';
+export function isSetPropTypeOp(op) {
+    return Boolean(op) && typeof op === 'object' && String(op.op ?? '') === SET_PROP_TYPE_OP;
+}
+export function setPropTypeErrors(ops) {
+    const issues = [];
+    for (const op of ops) {
+        const target = String(op.target ?? '');
+        const prop = String(op.prop ?? '');
+        const propType = String(op.propType ?? '');
+        if (!target || !prop) {
+            issues.push("set_prop_type için 'target' (elementId) ve 'prop' (prop adı) zorunludur.");
+            continue;
+        }
+        const carrier = PROP_TYPE_CARRIER[propType];
+        if (!carrier) {
+            issues.push(`set_prop_type '${target}.${prop}': geçersiz propType '${propType || '(boş)'}'. Yazılabilir tipler: ${Object.keys(PROP_TYPE_CARRIER).join(' · ')}.`);
+            continue;
+        }
+        if (carrier === 'ref' && String(op.ref ?? '').trim().length === 0) {
+            issues.push(`set_prop_type '${target}.${prop}': propType '${propType}' değeri 'ref' alanında taşır ve 'ref' boş. ${propType === 'translation' ? "translation_list ile çeviri anahtarını bulun (ör. ref: 'dashboard.kpi.total')" : "ref: '<ifade>' verin (ör. 'Page.variables.total')"} — runtime 'data'yı her turda ezer, anahtar yalnız ref'te yaşar.`);
+        }
+        if (carrier === 'data' && op.data === undefined && op.value === undefined) {
+            issues.push(`set_prop_type '${target}.${prop}': propType 'static' değeri 'data' alanında taşır ve 'data' verilmedi. Mevcut değeri korumak istiyorsanız data'yı açıkça yazın.`);
+        }
+    }
+    return issues;
+}
+/**
+ * Op'ları verilen ağaca uygular. Ağacı YERİNDE değiştirir — çağıran kopyayı kendisi alır, çünkü
+ * sayfa ve layout hatları gövdeyi farklı biçimde geri yazıyor (`pageUpdateBody` / `layoutUpdateBody`).
+ * Bulunamayan hedefler atılmaz, `missingTargets` ile döner: çağıran kendi aracının adını içeren
+ * hata mesajını kurar.
+ */
+export function applyPropTypesToSchema(schema, ops) {
+    const applied = [];
+    const missingTargets = [];
+    for (const op of ops) {
+        const target = String(op.target ?? '');
+        const prop = String(op.prop ?? '');
+        const propType = String(op.propType ?? '');
+        const node = findNode(schema, target);
+        if (!node) {
+            missingTargets.push(target);
+            continue;
+        }
+        const props = (node.props ?? {});
+        const existing = props[prop];
+        const current = existing && typeof existing === 'object' && !Array.isArray(existing)
+            ? existing
+            : undefined;
+        // `data` tasarım zamanı yedeğidir: `code`/`translation`'a geçerken mevcut metni koruyoruz ki
+        // Studio'da boş kutu görünmesin (runtime onu zaten çözümlenmiş değerle ezer).
+        const carried = op.data !== undefined ? op.data : op.value !== undefined ? op.value : current?.data ?? null;
+        props[prop] = propType === 'static'
+            ? { type: 'static', ref: null, data: carried }
+            : { type: propType, ref: String(op.ref), data: carried };
+        node.props = props;
+        applied.push(`${target}.${prop}: ${current?.type ?? '(yok)'} → ${propType}`);
+    }
+    return { applied, missingTargets };
+}