vantuz 3.4.2 → 3.5.1

package/core/memory.js

@@ -1,190 +1,190 @@
-// core/memory.js
-// Persistent Memory Module for Vantuz AI
-// Provides long-term fact storage and recall via JSON files.
-
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
-
-const MEMORY_DIR = path.join(os.homedir(), '.vantuz', 'memory');
-const FACTS_FILE = path.join(MEMORY_DIR, 'facts.json');
-const STRATEGY_FILE = path.join(MEMORY_DIR, 'strategy.json');
-const MAX_FACTS = 500;
-
-/**
- * Ensures the memory directory exists.
- */
-function ensureDir() {
-    if (!fs.existsSync(MEMORY_DIR)) {
-        fs.mkdirSync(MEMORY_DIR, { recursive: true });
-        log('INFO', 'Memory directory created', { path: MEMORY_DIR });
-    }
-}
-
-/**
- * Loads a JSON file safely.
- */
-function loadJson(filePath) {
-    try {
-        if (fs.existsSync(filePath)) {
-            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        }
-    } catch (e) {
-        log('WARN', `Memory file corrupt or unreadable: ${filePath}`, { error: e.message });
-    }
-    return [];
-}
-
-/**
- * Saves data to a JSON file atomically.
- */
-function saveJson(filePath, data) {
-    ensureDir();
-    const tmp = filePath + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
-    fs.renameSync(tmp, filePath);
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// MEMORY CLASS
-// ═══════════════════════════════════════════════════════════════════════════
-
-class Memory {
-    constructor() {
-        ensureDir();
-        this.facts = loadJson(FACTS_FILE);
-        this.strategies = loadJson(STRATEGY_FILE);
-        log('INFO', 'Memory loaded', {
-            facts: this.facts.length,
-            strategies: this.strategies.length
-        });
-    }
-
-    /**
-     * Remember a fact. Facts are timestamped entries.
-     * @param {string} fact - The fact to remember.
-     * @param {string} category - Category: 'general', 'customer', 'product', 'strategy'
-     */
-    remember(fact, category = 'general') {
-        const entry = {
-            id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
-            fact,
-            category,
-            createdAt: new Date().toISOString()
-        };
-
-        this.facts.push(entry);
-
-        // Evict oldest if over limit
-        if (this.facts.length > MAX_FACTS) {
-            this.facts = this.facts.slice(-MAX_FACTS);
-        }
-
-        saveJson(FACTS_FILE, this.facts);
-        log('INFO', 'Fact remembered', { id: entry.id, category });
-        return entry;
-    }
-
-    /**
-     * Recall facts matching a keyword query.
-     * Simple substring search (can be upgraded to vector later).
-     * @param {string} query - Search query.
-     * @param {number} limit - Max results.
-     * @returns {Array} Matching facts.
-     */
-    recall(query, limit = 10) {
-        const q = query.toLowerCase();
-        const matches = this.facts.filter(f =>
-            f.fact.toLowerCase().includes(q) ||
-            f.category.toLowerCase().includes(q)
-        );
-        return matches.slice(-limit);
-    }
-
-    /**
-     * Save a strategic decision or rule.
-     * @param {string} rule - The strategy rule.
-     * @param {string} context - Why this decision was made.
-     */
-    addStrategy(rule, context = '') {
-        const entry = {
-            id: Date.now().toString(36),
-            rule,
-            context,
-            createdAt: new Date().toISOString()
-        };
-
-        this.strategies.push(entry);
-        saveJson(STRATEGY_FILE, this.strategies);
-        log('INFO', 'Strategy recorded', { id: entry.id });
-        return entry;
-    }
-
-    /**
-     * Get all strategies.
-     */
-    getStrategies() {
-        return this.strategies;
-    }
-
-    /**
-     * Get recent facts for context injection.
-     * @param {number} count - How many recent facts.
-     */
-    getRecentFacts(count = 20) {
-        return this.facts.slice(-count);
-    }
-
-    /**
-     * Get a summary string for AI injection.
-     */
-    getContextSummary() {
-        const recentFacts = this.getRecentFacts(10);
-        const strategies = this.getStrategies();
-
-        let summary = '';
-
-        if (strategies.length > 0) {
-            summary += '\n--- STRATEJİK KURALLAR ---\n';
-            strategies.forEach(s => {
-                summary += `- ${s.rule}\n`;
-            });
-        }
-
-        if (recentFacts.length > 0) {
-            summary += '\n--- SON HATIRALAR ---\n';
-            recentFacts.forEach(f => {
-                summary += `- [${f.category}] ${f.fact}\n`;
-            });
-        }
-
-        return summary;
-    }
-
-    /**
-     * Full reset (dangerous).
-     */
-    clear() {
-        this.facts = [];
-        this.strategies = [];
-        saveJson(FACTS_FILE, this.facts);
-        saveJson(STRATEGY_FILE, this.strategies);
-        log('WARN', 'Memory cleared');
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SINGLETON
-// ═══════════════════════════════════════════════════════════════════════════
-
-let memoryInstance = null;
-
-export function getMemory() {
-    if (!memoryInstance) {
-        memoryInstance = new Memory();
-    }
-    return memoryInstance;
-}
-
-export default Memory;
+// core/memory.js
+// Persistent Memory Module for Vantuz AI
+// Provides long-term fact storage and recall via JSON files.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from './ai-provider.js';
+
+const MEMORY_DIR = path.join(os.homedir(), '.vantuz', 'memory');
+const FACTS_FILE = path.join(MEMORY_DIR, 'facts.json');
+const STRATEGY_FILE = path.join(MEMORY_DIR, 'strategy.json');
+const MAX_FACTS = 500;
+
+/**
+ * Ensures the memory directory exists.
+ */
+function ensureDir() {
+    if (!fs.existsSync(MEMORY_DIR)) {
+        fs.mkdirSync(MEMORY_DIR, { recursive: true });
+        log('INFO', 'Memory directory created', { path: MEMORY_DIR });
+    }
+}
+
+/**
+ * Loads a JSON file safely.
+ */
+function loadJson(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    } catch (e) {
+        log('WARN', `Memory file corrupt or unreadable: ${filePath}`, { error: e.message });
+    }
+    return [];
+}
+
+/**
+ * Saves data to a JSON file atomically.
+ */
+function saveJson(filePath, data) {
+    ensureDir();
+    const tmp = filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, filePath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MEMORY CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+
+class Memory {
+    constructor() {
+        ensureDir();
+        this.facts = loadJson(FACTS_FILE);
+        this.strategies = loadJson(STRATEGY_FILE);
+        log('INFO', 'Memory loaded', {
+            facts: this.facts.length,
+            strategies: this.strategies.length
+        });
+    }
+
+    /**
+     * Remember a fact. Facts are timestamped entries.
+     * @param {string} fact - The fact to remember.
+     * @param {string} category - Category: 'general', 'customer', 'product', 'strategy'
+     */
+    remember(fact, category = 'general') {
+        const entry = {
+            id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+            fact,
+            category,
+            createdAt: new Date().toISOString()
+        };
+
+        this.facts.push(entry);
+
+        // Evict oldest if over limit
+        if (this.facts.length > MAX_FACTS) {
+            this.facts = this.facts.slice(-MAX_FACTS);
+        }
+
+        saveJson(FACTS_FILE, this.facts);
+        log('INFO', 'Fact remembered', { id: entry.id, category });
+        return entry;
+    }
+
+    /**
+     * Recall facts matching a keyword query.
+     * Simple substring search (can be upgraded to vector later).
+     * @param {string} query - Search query.
+     * @param {number} limit - Max results.
+     * @returns {Array} Matching facts.
+     */
+    recall(query, limit = 10) {
+        const q = query.toLowerCase();
+        const matches = this.facts.filter(f =>
+            f.fact.toLowerCase().includes(q) ||
+            f.category.toLowerCase().includes(q)
+        );
+        return matches.slice(-limit);
+    }
+
+    /**
+     * Save a strategic decision or rule.
+     * @param {string} rule - The strategy rule.
+     * @param {string} context - Why this decision was made.
+     */
+    addStrategy(rule, context = '') {
+        const entry = {
+            id: Date.now().toString(36),
+            rule,
+            context,
+            createdAt: new Date().toISOString()
+        };
+
+        this.strategies.push(entry);
+        saveJson(STRATEGY_FILE, this.strategies);
+        log('INFO', 'Strategy recorded', { id: entry.id });
+        return entry;
+    }
+
+    /**
+     * Get all strategies.
+     */
+    getStrategies() {
+        return this.strategies;
+    }
+
+    /**
+     * Get recent facts for context injection.
+     * @param {number} count - How many recent facts.
+     */
+    getRecentFacts(count = 20) {
+        return this.facts.slice(-count);
+    }
+
+    /**
+     * Get a summary string for AI injection.
+     */
+    getContextSummary() {
+        const recentFacts = this.getRecentFacts(10);
+        const strategies = this.getStrategies();
+
+        let summary = '';
+
+        if (strategies.length > 0) {
+            summary += '\n--- STRATEJİK KURALLAR ---\n';
+            strategies.forEach(s => {
+                summary += `- ${s.rule}\n`;
+            });
+        }
+
+        if (recentFacts.length > 0) {
+            summary += '\n--- SON HATIRALAR ---\n';
+            recentFacts.forEach(f => {
+                summary += `- [${f.category}] ${f.fact}\n`;
+            });
+        }
+
+        return summary;
+    }
+
+    /**
+     * Full reset (dangerous).
+     */
+    clear() {
+        this.facts = [];
+        this.strategies = [];
+        saveJson(FACTS_FILE, this.facts);
+        saveJson(STRATEGY_FILE, this.strategies);
+        log('WARN', 'Memory cleared');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SINGLETON
+// ═══════════════════════════════════════════════════════════════════════════
+
+let memoryInstance = null;
+
+export function getMemory() {
+    if (!memoryInstance) {
+        memoryInstance = new Memory();
+    }
+    return memoryInstance;
+}
+
+export default Memory;

package/core/migrations/001-initial-schema.sql

@@ -17,4 +17,4 @@ CREATE TABLE historical_prices (
 
 -- down
 DROP TABLE IF EXISTS historical_prices;
-DROP TABLE IF EXISTS products;
+DROP TABLE IF EXISTS products;

package/core/queue.js

@@ -1,120 +1,120 @@
-// core/queue.js
-// Critical Operation Queue (Lane Queue) for Vantuz AI
-// Ensures write operations (price/stock updates) execute serially, never in parallel.
-
-import { log } from './ai-provider.js';
-
-class CriticalQueue {
-    constructor() {
-        this._queue = [];
-        this._running = false;
-        this._stats = { processed: 0, errors: 0, lastRun: null };
-        log('INFO', 'CriticalQueue (Lane Queue) initialized');
-    }
-
-    /**
-     * Enqueue a critical operation.
-     * @param {string} label - Human readable label (e.g. "Fiyat güncelle: SKU-123")
-     * @param {function} fn - Async function to execute.
-     * @param {object} options - { priority: 'high'|'normal', dryRun: false }
-     * @returns {Promise} Resolves when the operation completes.
-     */
-    enqueue(label, fn, options = {}) {
-        const { priority = 'normal', dryRun = false } = options;
-
-        return new Promise((resolve, reject) => {
-            const task = { label, fn, resolve, reject, priority, dryRun, enqueuedAt: Date.now() };
-
-            if (priority === 'high') {
-                // Insert at the front (after any currently running task)
-                this._queue.unshift(task);
-            } else {
-                this._queue.push(task);
-            }
-
-            log('INFO', `Operation queued: "${label}"`, {
-                position: this._queue.length,
-                dryRun,
-                priority
-            });
-
-            this._processNext();
-        });
-    }
-
-    /**
-     * Process the next item in the queue.
-     */
-    async _processNext() {
-        if (this._running || this._queue.length === 0) return;
-
-        this._running = true;
-        const task = this._queue.shift();
-
-        log('INFO', `▶ Executing: "${task.label}"`, {
-            waitedMs: Date.now() - task.enqueuedAt,
-            remaining: this._queue.length
-        });
-
-        try {
-            if (task.dryRun) {
-                log('INFO', `[DRY RUN] Would execute: "${task.label}"`);
-                task.resolve({ dryRun: true, label: task.label, status: 'skipped' });
-            } else {
-                const result = await task.fn();
-                this._stats.processed++;
-                this._stats.lastRun = new Date().toISOString();
-                task.resolve(result);
-            }
-        } catch (error) {
-            this._stats.errors++;
-            log('ERROR', `✘ Failed: "${task.label}"`, { error: error.message });
-            task.reject(error);
-        } finally {
-            this._running = false;
-            // Process next in queue
-            if (this._queue.length > 0) {
-                // Small delay to prevent tight loops
-                setTimeout(() => this._processNext(), 50);
-            }
-        }
-    }
-
-    /**
-     * Get queue status.
-     */
-    getStatus() {
-        return {
-            queueLength: this._queue.length,
-            isRunning: this._running,
-            pendingLabels: this._queue.map(t => t.label),
-            stats: { ...this._stats }
-        };
-    }
-
-    /**
-     * Drain the queue (cancel all pending, don't cancel running).
-     */
-    drain() {
-        const cancelled = this._queue.length;
-        this._queue.forEach(t => t.reject(new Error('Queue drained')));
-        this._queue = [];
-        log('WARN', `Queue drained, ${cancelled} operations cancelled`);
-        return cancelled;
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SINGLETON
-// ═══════════════════════════════════════════════════════════════════════════
-
-let queueInstance = null;
-
-export function getCriticalQueue() {
-    if (!queueInstance) {
-        queueInstance = new CriticalQueue();
-    }
-    return queueInstance;
-}
-
-export default CriticalQueue;
+// core/queue.js
+// Critical Operation Queue (Lane Queue) for Vantuz AI
+// Ensures write operations (price/stock updates) execute serially, never in parallel.
+
+import { log } from './ai-provider.js';
+
+class CriticalQueue {
+    constructor() {
+        this._queue = [];
+        this._running = false;
+        this._stats = { processed: 0, errors: 0, lastRun: null };
+        log('INFO', 'CriticalQueue (Lane Queue) initialized');
+    }
+
+    /**
+     * Enqueue a critical operation.
+     * @param {string} label - Human readable label (e.g. "Fiyat güncelle: SKU-123")
+     * @param {function} fn - Async function to execute.
+     * @param {object} options - { priority: 'high'|'normal', dryRun: false }
+     * @returns {Promise} Resolves when the operation completes.
+     */
+    enqueue(label, fn, options = {}) {
+        const { priority = 'normal', dryRun = false } = options;
+
+        return new Promise((resolve, reject) => {
+            const task = { label, fn, resolve, reject, priority, dryRun, enqueuedAt: Date.now() };
+
+            if (priority === 'high') {
+                // Insert at the front (after any currently running task)
+                this._queue.unshift(task);
+            } else {
+                this._queue.push(task);
+            }
+
+            log('INFO', `Operation queued: "${label}"`, {
+                position: this._queue.length,
+                dryRun,
+                priority
+            });
+
+            this._processNext();
+        });
+    }
+
+    /**
+     * Process the next item in the queue.
+     */
+    async _processNext() {
+        if (this._running || this._queue.length === 0) return;
+
+        this._running = true;
+        const task = this._queue.shift();
+
+        log('INFO', `▶ Executing: "${task.label}"`, {
+            waitedMs: Date.now() - task.enqueuedAt,
+            remaining: this._queue.length
+        });
+
+        try {
+            if (task.dryRun) {
+                log('INFO', `[DRY RUN] Would execute: "${task.label}"`);
+                task.resolve({ dryRun: true, label: task.label, status: 'skipped' });
+            } else {
+                const result = await task.fn();
+                this._stats.processed++;
+                this._stats.lastRun = new Date().toISOString();
+                task.resolve(result);
+            }
+        } catch (error) {
+            this._stats.errors++;
+            log('ERROR', `✘ Failed: "${task.label}"`, { error: error.message });
+            task.reject(error);
+        } finally {
+            this._running = false;
+            // Process next in queue
+            if (this._queue.length > 0) {
+                // Small delay to prevent tight loops
+                setTimeout(() => this._processNext(), 50);
+            }
+        }
+    }
+
+    /**
+     * Get queue status.
+     */
+    getStatus() {
+        return {
+            queueLength: this._queue.length,
+            isRunning: this._running,
+            pendingLabels: this._queue.map(t => t.label),
+            stats: { ...this._stats }
+        };
+    }
+
+    /**
+     * Drain the queue (cancel all pending, don't cancel running).
+     */
+    drain() {
+        const cancelled = this._queue.length;
+        this._queue.forEach(t => t.reject(new Error('Queue drained')));
+        this._queue = [];
+        log('WARN', `Queue drained, ${cancelled} operations cancelled`);
+        return cancelled;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SINGLETON
+// ═══════════════════════════════════════════════════════════════════════════
+
+let queueInstance = null;
+
+export function getCriticalQueue() {
+    if (!queueInstance) {
+        queueInstance = new CriticalQueue();
+    }
+    return queueInstance;
+}
+
+export default CriticalQueue;