@game_ryo/lsji 0.1.0

package/src/storage/memory.js

@@ -0,0 +1,98 @@
+/**
+ * In-Memory Storage Implementation
+ * 
+ * Pure JavaScript in-memory storage using Maps/Arrays.
+ * Ideal for testing, CI, and ephemeral workloads.
+ * No persistence - data lost on process exit.
+ */
+
+import { Storage } from './index.js';
+
+/**
+ * MemoryStorage - In-memory implementation
+ */
+export class MemoryStorage extends Storage {
+  constructor() {
+    super();
+    this.settings = new Map();
+    this.battleHistory = [];
+    this.qTable = new Map(); // key: "state:action" -> q_value
+    this.initialized = false;
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+    this.settings.set('is_active', '1');
+    this.initialized = true;
+  }
+
+  async close() {
+    // No-op for memory storage
+  }
+
+  async getSetting(key) {
+    const value = this.settings.get(key);
+    return value ? { key, value } : null;
+  }
+
+  async setSetting(key, value) {
+    this.settings.set(key, String(value));
+  }
+
+  async getQTable() {
+    const results = [];
+    for (const [key, qValue] of this.qTable) {
+      const [state, action] = key.split(':');
+      results.push({ state, action: parseInt(action, 10), q_value: qValue });
+    }
+    return results.sort((a, b) => a.state.localeCompare(b.state) || a.action - b.action);
+  }
+
+  async updateQ(state, action, qValue) {
+    this.qTable.set(`${state}:${action}`, qValue);
+  }
+
+  async addBattle(record) {
+    this.battleHistory.push({
+      id: this.battleHistory.length + 1,
+      ...record
+    });
+  }
+
+  async getTodayBattleCount() {
+    const today = new Date().toISOString().split('T')[0];
+    return this.battleHistory.filter(
+      r => r.createdAt.startsWith(today)
+    ).length;
+  }
+
+  async getPerformanceStats() {
+    const stats = new Map();
+    
+    for (const record of this.battleHistory) {
+      const mode = record.mode;
+      if (!stats.has(mode)) {
+        stats.set(mode, { total: 0, wins: 0 });
+      }
+      const stat = stats.get(mode);
+      stat.total++;
+      if (record.reward > 0) stat.wins++;
+    }
+    
+    return Array.from(stats.entries()).map(([mode, stat]) => ({
+      mode,
+      total: stat.total,
+      win_rate: stat.total > 0 ? Math.round((stat.wins / stat.total) * 1000) / 10 : 0
+    }));
+  }
+
+  /**
+   * Clear all data (useful for testing)
+   */
+  clear() {
+    this.settings.clear();
+    this.battleHistory = [];
+    this.qTable.clear();
+    this.settings.set('is_active', '1');
+  }
+}

package/src/storage/sqlite.js

@@ -0,0 +1,123 @@
+/**
+ * SQLite Storage Implementation using node:sqlite (Node.js 22+ built-in)
+ * 
+ * Zero-dependency SQLite implementation using Node.js built-in module.
+ * Recommended for most use cases.
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { Storage } from './index.js';
+
+/**
+ * SqliteStorage - Uses node:sqlite (synchronous API)
+ */
+export class SqliteStorage extends Storage {
+  /**
+   * @param {string} path - Database file path
+   */
+  constructor(path = './lsji.db') {
+    super();
+    this.path = path;
+    this.db = null;
+  }
+
+  async initialize() {
+    this.db = new DatabaseSync(this.path);
+    
+    // Create tables
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      
+      CREATE TABLE IF NOT EXISTS battle_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        mode TEXT NOT NULL CHECK (mode IN ('train', 'test')),
+        hand_a INTEGER NOT NULL,
+        hand_b INTEGER NOT NULL,
+        reward INTEGER NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      
+      CREATE TABLE IF NOT EXISTS q_table (
+        state TEXT NOT NULL,
+        action INTEGER NOT NULL,
+        q_value REAL NOT NULL DEFAULT 0,
+        PRIMARY KEY (state, action)
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_battle_history_date 
+        ON battle_history(created_at);
+      CREATE INDEX IF NOT EXISTS idx_battle_history_mode 
+        ON battle_history(mode);
+    `);
+    
+    // Initialize default settings
+    const stmt = this.db.prepare('INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)');
+    stmt.run('is_active', '1');
+  }
+
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  async getSetting(key) {
+    const stmt = this.db.prepare('SELECT key, value FROM settings WHERE key = ?');
+    const row = stmt.get(key);
+    return row ? { key: row.key, value: row.value } : null;
+  }
+
+  async setSetting(key, value) {
+    const stmt = this.db.prepare(
+      'INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?'
+    );
+    stmt.run(key, String(value), String(value));
+  }
+
+  async getQTable() {
+    const stmt = this.db.prepare('SELECT state, action, q_value FROM q_table ORDER BY state, action');
+    return stmt.all();
+  }
+
+  async updateQ(state, action, qValue) {
+    const stmt = this.db.prepare(`
+      INSERT INTO q_table (state, action, q_value) VALUES (?, ?, ?)
+      ON CONFLICT(state, action) DO UPDATE SET q_value = ?
+    `);
+    stmt.run(state, action, qValue, qValue);
+  }
+
+  async addBattle(record) {
+    const stmt = this.db.prepare(`
+      INSERT INTO battle_history (mode, hand_a, hand_b, reward, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(record.mode, record.handA, record.handB, record.reward, record.createdAt);
+  }
+
+  async getTodayBattleCount() {
+    const today = new Date().toISOString().split('T')[0];
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count FROM battle_history 
+      WHERE date(created_at) = date(?)
+    `);
+    const row = stmt.get(today);
+    return row ? row.count : 0;
+  }
+
+  async getPerformanceStats() {
+    const stmt = this.db.prepare(`
+      SELECT 
+        mode,
+        COUNT(*) as total,
+        ROUND(AVG(CASE WHEN reward > 0 THEN 1.0 ELSE 0.0 END) * 100, 1) as win_rate
+      FROM battle_history 
+      GROUP BY mode
+    `);
+    return stmt.all();
+  }
+}

package/test/core/qlearning.test.js

@@ -0,0 +1,150 @@
+/**
+ * QLearning Tests
+ * 
+ * Verifies the TD learning logic matches original worker.js behavior.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { QLearning } from '../../src/core/qlearning.js';
+import { MemoryStorage } from '../../src/storage/memory.js';
+
+describe('QLearning', () => {
+  let storage;
+  let qlearning;
+
+  beforeEach(async () => {
+    storage = new MemoryStorage();
+    await storage.initialize();
+    qlearning = new QLearning({ alpha: 0.1, gamma: 0.9, epsilon: 0.1, storage });
+  });
+
+  it('should initialize with default config', () => {
+    expect(qlearning.alpha).toBe(0.1);
+    expect(qlearning.gamma).toBe(0.9);
+    expect(qlearning.epsilon).toBe(0.1);
+  });
+
+  it('should clamp alpha, gamma, epsilon to [0, 1]', () => {
+    const ql = new QLearning({ alpha: 1.5, gamma: -0.5, epsilon: 2, storage });
+    expect(ql.alpha).toBe(1);
+    expect(ql.gamma).toBe(0);
+    expect(ql.epsilon).toBe(1);
+  });
+
+  it('should return 0 for unseen state-action pairs', async () => {
+    await qlearning.initialize();
+    const value = qlearning.getQValue('state1', 0);
+    expect(value).toBe(0);
+  });
+
+  it('should store and retrieve Q-values', async () => {
+    await qlearning.initialize();
+    await qlearning.setQValue('state1', 0, 0.5);
+    expect(qlearning.getQValue('state1', 0)).toBe(0.5);
+  });
+
+  it('should perform simple TD update (worker.js style)', async () => {
+    await qlearning.initialize();
+    
+    // Original worker.js: oldQ + 0.1 * (reward - oldQ)
+    // Initial Q = 0, reward = 1 (win)
+    // New Q = 0 + 0.1 * (1 - 0) = 0.1
+    await qlearning.learnSimple('state1', 0, 1);
+    expect(qlearning.getQValue('state1', 0)).toBeCloseTo(0.1);
+    
+    // Second update: oldQ = 0.1, reward = 1
+    // New Q = 0.1 + 0.1 * (1 - 0.1) = 0.19
+    await qlearning.learnSimple('state1', 0, 1);
+    expect(qlearning.getQValue('state1', 0)).toBeCloseTo(0.19);
+  });
+
+  it('should handle negative rewards (loss)', async () => {
+    await qlearning.initialize();
+    
+    // reward = -1 (loss)
+    // New Q = 0 + 0.1 * (-1 - 0) = -0.1
+    await qlearning.learnSimple('state1', 0, -1);
+    expect(qlearning.getQValue('state1', 0)).toBeCloseTo(-0.1);
+  });
+
+  it('should handle zero rewards (draw)', async () => {
+    await qlearning.initialize();
+    
+    // reward = 0 (draw)
+    // New Q = 0 + 0.1 * (0 - 0) = 0
+    await qlearning.learnSimple('state1', 0, 0);
+    expect(qlearning.getQValue('state1', 0)).toBe(0);
+  });
+
+  it('should select random action during exploration', async () => {
+    await qlearning.initialize();
+    
+    // With epsilon=1, should always explore
+    const ql = new QLearning({ alpha: 0.1, gamma: 0.9, epsilon: 1, storage });
+    await ql.initialize();
+    
+    const actions = new Set();
+    for (let i = 0; i < 100; i++) {
+      actions.add(await ql.act('state1', 3));
+    }
+    
+    // Should have tried multiple actions
+    expect(actions.size).toBeGreaterThan(1);
+  });
+
+  it('should select best action during exploitation', async () => {
+    await qlearning.initialize();
+    
+    // Set up Q-values: action 1 is best
+    await qlearning.setQValue('state1', 0, 0.1);
+    await qlearning.setQValue('state1', 1, 0.9);
+    await qlearning.setQValue('state1', 2, 0.3);
+    
+    // With epsilon=0, should always exploit
+    const ql = new QLearning({ alpha: 0.1, gamma: 0.9, epsilon: 0, storage });
+    await ql.initialize();
+    
+    const action = await ql.act('state1', 3);
+    expect(action).toBe(1);
+  });
+
+  it('should perform full TD update with next state', async () => {
+    await qlearning.initialize();
+    
+    // Set up next state with known values
+    await qlearning.setQValue('nextState', 0, 0.5);
+    await qlearning.setQValue('nextState', 1, 0.8);
+    
+    // Current: state1, action 0, Q=0
+    // Reward = 1, gamma = 0.9, max next Q = 0.8
+    // Target = 1 + 0.9 * 0.8 = 1.72
+    // New Q = 0 + 0.1 * (1.72 - 0) = 0.172
+    await qlearning.learn('state1', 0, 1, 'nextState', 2);
+    
+    expect(qlearning.getQValue('state1', 0)).toBeCloseTo(0.172, 2);
+  });
+
+  it('should persist Q-values to storage', async () => {
+    await qlearning.initialize();
+    await qlearning.setQValue('state1', 0, 0.5);
+    
+    // Create new QLearning instance with same storage
+    const ql2 = new QLearning({ alpha: 0.1, gamma: 0.9, epsilon: 0.1, storage });
+    await ql2.initialize();
+    
+    expect(ql2.getQValue('state1', 0)).toBe(0.5);
+  });
+
+  it('should return full Q-table', async () => {
+    await qlearning.initialize();
+    await qlearning.setQValue('stateA', 0, 0.1);
+    await qlearning.setQValue('stateA', 1, 0.2);
+    await qlearning.setQValue('stateB', 0, 0.3);
+    
+    const table = await qlearning.getFullQTable();
+    expect(table.length).toBe(3);
+    expect(table[0]).toEqual({ state: 'stateA', action: 0, q_value: 0.1 });
+    expect(table[1]).toEqual({ state: 'stateA', action: 1, q_value: 0.2 });
+    expect(table[2]).toEqual({ state: 'stateB', action: 0, q_value: 0.3 });
+  });
+});

package/test/storage/memory.test.js

@@ -0,0 +1,81 @@
+/**
+ * MemoryStorage Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryStorage } from '../../src/storage/memory.js';
+
+describe('MemoryStorage', () => {
+  let storage;
+
+  beforeEach(async () => {
+    storage = new MemoryStorage();
+    await storage.initialize();
+  });
+
+  it('should initialize with default settings', async () => {
+    const setting = await storage.getSetting('is_active');
+    expect(setting).toEqual({ key: 'is_active', value: '1' });
+  });
+
+  it('should get and set settings', async () => {
+    await storage.setSetting('test_key', 'test_value');
+    const setting = await storage.getSetting('test_key');
+    expect(setting).toEqual({ key: 'test_key', value: 'test_value' });
+  });
+
+  it('should return null for missing settings', async () => {
+    const setting = await storage.getSetting('nonexistent');
+    expect(setting).toBeNull();
+  });
+
+  it('should add and retrieve battles', async () => {
+    await storage.addBattle({
+      mode: 'test',
+      handA: 0,
+      handB: 1,
+      reward: 1,
+      createdAt: '2026-01-01T00:00:00Z'
+    });
+
+    const count = await storage.getTodayBattleCount();
+    // Note: this depends on current date, so we just check it's a number
+    expect(typeof count).toBe('number');
+  });
+
+  it('should track Q-table', async () => {
+    await storage.updateQ('state1', 0, 0.5);
+    
+    const qTable = await storage.getQTable();
+    expect(qTable.length).toBe(1);
+    expect(qTable[0]).toEqual({ state: 'state1', action: 0, q_value: 0.5 });
+  });
+
+  it('should compute performance stats', async () => {
+    // Add some battles
+    await storage.addBattle({ mode: 'test', handA: 0, handB: 1, reward: 1, createdAt: new Date().toISOString() });
+    await storage.addBattle({ mode: 'test', handA: 0, handB: 2, reward: -1, createdAt: new Date().toISOString() });
+    await storage.addBattle({ mode: 'train', handA: 1, handB: 0, reward: 0, createdAt: new Date().toISOString() });
+
+    const stats = await storage.getPerformanceStats();
+    expect(stats.length).toBe(2); // test and train
+    
+    const testStat = stats.find(s => s.mode === 'test');
+    expect(testStat.total).toBe(2);
+    expect(testStat.win_rate).toBe(50); // 1 win out of 2
+  });
+
+  it('should clear all data', async () => {
+    await storage.setSetting('test', 'value');
+    await storage.addBattle({ mode: 'test', handA: 0, handB: 1, reward: 1, createdAt: new Date().toISOString() });
+    await storage.updateQ('state1', 0, 0.5);
+    
+    storage.clear();
+    
+    const setting = await storage.getSetting('test');
+    expect(setting).toBeNull();
+    
+    const count = await storage.getTodayBattleCount();
+    expect(count).toBe(0);
+  });
+});