appback-ai-agent 1.0.0

package/src/data/storage/SqliteStore.js

@@ -0,0 +1,172 @@
+const Database = require('better-sqlite3')
+const path = require('path')
+const { createLogger } = require('../../utils/logger')
+const log = createLogger('sqlite')
+
+class SqliteStore {
+  constructor(dataDir) {
+    const dbPath = path.join(dataDir || './data', 'agent.db')
+    this.db = new Database(dbPath)
+    this.db.pragma('journal_mode = WAL')
+    this._initSchema()
+    log.info(`SQLite database: ${dbPath}`)
+  }
+
+  _initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_identity (
+        game TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        api_token TEXT NOT NULL,
+        name TEXT,
+        registered_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS game_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        game TEXT NOT NULL,
+        game_id TEXT NOT NULL,
+        started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        ended_at DATETIME,
+        my_slot INTEGER,
+        result TEXT,
+        model_version TEXT,
+        strategy_log TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS battle_ticks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id INTEGER REFERENCES game_sessions(id),
+        tick INTEGER NOT NULL,
+        sub_tick INTEGER NOT NULL,
+        state TEXT NOT NULL,
+        my_features TEXT,
+        my_decision TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS training_samples (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        model_type TEXT NOT NULL,
+        features BLOB NOT NULL,
+        label INTEGER NOT NULL,
+        reward REAL,
+        session_id INTEGER REFERENCES game_sessions(id),
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS model_metrics (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        model_key TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        games_played INTEGER DEFAULT 0,
+        avg_rank REAL,
+        avg_score REAL,
+        win_rate REAL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_ticks_session ON battle_ticks(session_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_game ON game_sessions(game, game_id);
+    `)
+    log.info('Schema initialized')
+  }
+
+  // --- Identity ---
+  saveIdentity(game, agentId, apiToken, name) {
+    this.db.prepare(`
+      INSERT OR REPLACE INTO agent_identity (game, agent_id, api_token, name)
+      VALUES (?, ?, ?, ?)
+    `).run(game, agentId, apiToken, name)
+  }
+
+  getIdentity(game) {
+    return this.db.prepare('SELECT * FROM agent_identity WHERE game = ?').get(game)
+  }
+
+  // --- Game Sessions ---
+  startSession(game, gameId, mySlot) {
+    const info = this.db.prepare(`
+      INSERT INTO game_sessions (game, game_id, my_slot) VALUES (?, ?, ?)
+    `).run(game, gameId, mySlot)
+    return info.lastInsertRowid
+  }
+
+  endSession(sessionId, result, strategyLog) {
+    this.db.prepare(`
+      UPDATE game_sessions SET ended_at = CURRENT_TIMESTAMP, result = ?, strategy_log = ?
+      WHERE id = ?
+    `).run(JSON.stringify(result), JSON.stringify(strategyLog), sessionId)
+  }
+
+  // --- Battle Ticks ---
+  recordTick(sessionId, tick, subTick, state, features, decision) {
+    this.db.prepare(`
+      INSERT INTO battle_ticks (session_id, tick, sub_tick, state, my_features, my_decision)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(
+      sessionId, tick, subTick,
+      JSON.stringify(state),
+      features ? JSON.stringify(features) : null,
+      decision ? JSON.stringify(decision) : null
+    )
+  }
+
+  // Batch insert for performance
+  recordTickBatch(rows) {
+    const stmt = this.db.prepare(`
+      INSERT INTO battle_ticks (session_id, tick, sub_tick, state, my_features, my_decision)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `)
+    const tx = this.db.transaction((items) => {
+      for (const r of items) {
+        stmt.run(
+          r.sessionId, r.tick, r.subTick,
+          JSON.stringify(r.state),
+          r.features ? JSON.stringify(r.features) : null,
+          r.decision ? JSON.stringify(r.decision) : null
+        )
+      }
+    })
+    tx(rows)
+  }
+
+  // --- Training Samples ---
+  saveSample(modelType, features, label, reward, sessionId) {
+    const buf = Buffer.from(Float32Array.from(features).buffer)
+    this.db.prepare(`
+      INSERT INTO training_samples (model_type, features, label, reward, session_id)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(modelType, buf, label, reward, sessionId)
+  }
+
+  getSampleCount(modelType) {
+    const row = this.db.prepare('SELECT COUNT(*) as cnt FROM training_samples WHERE model_type = ?').get(modelType)
+    return row.cnt
+  }
+
+  // --- Model Metrics ---
+  recordMetrics(modelKey, version, gamesPlayed, avgRank, avgScore, winRate) {
+    this.db.prepare(`
+      INSERT INTO model_metrics (model_key, version, games_played, avg_rank, avg_score, win_rate)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(modelKey, version, gamesPlayed, avgRank, avgScore, winRate)
+  }
+
+  // --- Stats ---
+  getSessionCount(game) {
+    const row = this.db.prepare('SELECT COUNT(*) as cnt FROM game_sessions WHERE game = ?').get(game)
+    return row.cnt
+  }
+
+  getRecentSessions(game, limit = 10) {
+    return this.db.prepare(`
+      SELECT * FROM game_sessions WHERE game = ? ORDER BY id DESC LIMIT ?
+    `).all(game, limit)
+  }
+
+  close() {
+    this.db.close()
+  }
+}
+
+module.exports = SqliteStore

package/src/index.js

@@ -0,0 +1,109 @@
+// CLI(bin/cli.js)에서 이미 로드한 경우 스킵
+if (!process.env._PKG_ROOT) require('dotenv').config()
+
+const path = require('path')
+const AgentManager = require('./core/AgentManager')
+const EventBus = require('./core/EventBus')
+const ModelRegistry = require('./core/ModelRegistry')
+const DataCollector = require('./core/DataCollector')
+const TrainingRunner = require('./core/TrainingRunner')
+const HealthMonitor = require('./core/HealthMonitor')
+const TrainingExporter = require('./data/exporters/TrainingExporter')
+const SqliteStore = require('./data/storage/SqliteStore')
+const Metrics = require('./utils/metrics')
+const GcAdapter = require('./adapters/gc/GcAdapter')
+const gcConfig = require('./adapters/gc/config')
+const { createLogger } = require('./utils/logger')
+
+const log = createLogger('main')
+
+async function main() {
+  log.info('appback-ai-agent v0.4.0 starting...')
+
+  const eventBus = new EventBus()
+  const modelDir = process.env.MODEL_DIR || './models'
+  const dataDir = process.env.DATA_DIR || './data'
+  const autoTrainAfter = parseInt(process.env.AUTO_TRAIN_AFTER_GAMES || '50')
+  const healthPort = parseInt(process.env.HEALTH_PORT || '9090')
+
+  // Data layer
+  const store = new SqliteStore(dataDir)
+  const dataCollector = new DataCollector(store)
+  const modelRegistry = new ModelRegistry(modelDir)
+  const metrics = new Metrics(store)
+  const exporter = new TrainingExporter(store)
+  const pkgRoot = process.env._PKG_ROOT || path.resolve(__dirname, '..')
+  const trainingDataDir = path.join(pkgRoot, 'training', 'data', 'raw')
+  const trainer = new TrainingRunner({
+    dataDir: trainingDataDir,
+    outputDir: `${modelDir}/gc`,
+    autoTrainAfterGames: autoTrainAfter,
+  })
+
+  // Load historical metrics
+  metrics.load('claw-clash')
+
+  const config = {
+    discoveryIntervalSec: parseInt(process.env.GAME_DISCOVERY_INTERVAL_SEC || '30'),
+  }
+
+  const manager = new AgentManager(config)
+
+  // Register gc adapter with metrics
+  const gc = new GcAdapter({
+    config: gcConfig,
+    modelRegistry,
+    dataCollector,
+    eventBus,
+    metrics,
+  })
+  manager.registerAdapter(gc)
+
+  // Health monitor
+  const health = new HealthMonitor(healthPort, metrics, manager.adapters)
+  health.start()
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    log.info('Shutting down...')
+    health.stop()
+    await manager.stop()
+    store.close()
+    process.exit(0)
+  }
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+
+  // Start
+  await manager.start()
+
+  // Event handlers
+  eventBus.on('game_found', ({ game, gameId }) => {
+    log.info(`Game found: ${game} / ${gameId}`)
+  })
+
+  // Auto-training pipeline after games
+  eventBus.on('game_ended', async ({ game, gameId }) => {
+    log.info(`Game completed: ${game} / ${gameId}`)
+
+    const totalGames = dataCollector.getSessionCount(game)
+
+    if (totalGames > 0 && totalGames % autoTrainAfter === 0 && !trainer.isRunning) {
+      log.info(`Auto-train threshold reached (${totalGames} games), starting pipeline...`)
+
+      const result = exporter.exportForTraining(game)
+      if (result) {
+        trainer.run(game).then(success => {
+          if (success) {
+            log.info('New model will be loaded automatically via hot-reload')
+          }
+        })
+      }
+    }
+  })
+}
+
+main().catch(err => {
+  log.error('Fatal error', err.message)
+  process.exit(1)
+})

package/src/models/providers/OnnxProvider.js

@@ -0,0 +1,78 @@
+const BaseModelProvider = require('../../core/BaseModelProvider')
+const { createLogger } = require('../../utils/logger')
+const log = createLogger('onnx')
+
+let ort = null
+try {
+  ort = require('onnxruntime-node')
+} catch {
+  log.warn('onnxruntime-node not available, ONNX inference disabled')
+}
+
+class OnnxProvider extends BaseModelProvider {
+  constructor(name, config = {}) {
+    super(name, config)
+    this.session = null
+    this.featureDim = config.featureDim || 0
+  }
+
+  async load(modelPath) {
+    if (!ort) throw new Error('onnxruntime-node not installed')
+    try {
+      this.session = await ort.InferenceSession.create(modelPath, {
+        executionProviders: ['cpu'],
+      })
+      this._loaded = true
+      log.info(`Model loaded: ${this.name} (${modelPath})`)
+    } catch (err) {
+      log.error(`Failed to load model: ${this.name}`, err.message)
+      throw err
+    }
+  }
+
+  async infer(features) {
+    if (!this.session) return null
+    const start = Date.now()
+    try {
+      const tensor = new ort.Tensor(
+        'float32',
+        Float32Array.from(features),
+        [1, features.length]
+      )
+      const results = await this.session.run({ input: tensor })
+      const outputKey = Object.keys(results)[0]
+      const logits = Array.from(results[outputKey].data)
+      const idx = argmax(logits)
+      const probs = softmax(logits)
+
+      this._lastInferenceMs = Date.now() - start
+      return { logits, decision: idx, confidence: probs[idx], probs }
+    } catch (err) {
+      log.error(`Inference error: ${this.name}`, err.message)
+      return null
+    }
+  }
+
+  async unload() {
+    this.session = null
+    this._loaded = false
+    log.info(`Model unloaded: ${this.name}`)
+  }
+}
+
+function argmax(arr) {
+  let maxIdx = 0, maxVal = arr[0]
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i] > maxVal) { maxVal = arr[i]; maxIdx = i }
+  }
+  return maxIdx
+}
+
+function softmax(arr) {
+  const max = Math.max(...arr)
+  const exp = arr.map(x => Math.exp(x - max))
+  const sum = exp.reduce((a, b) => a + b)
+  return exp.map(x => x / sum)
+}
+
+module.exports = OnnxProvider

package/src/models/providers/RuleBasedProvider.js

@@ -0,0 +1,18 @@
+const BaseModelProvider = require('../../core/BaseModelProvider')
+
+class RuleBasedProvider extends BaseModelProvider {
+  constructor() {
+    super('rule-based', {})
+    this._loaded = true
+  }
+
+  async load() { this._loaded = true }
+
+  async infer(features) {
+    // Rule-based doesn't use feature vectors
+    // Strategy decisions are handled by GcStrategyEngine
+    return { decision: null, confidence: 0 }
+  }
+}
+
+module.exports = RuleBasedProvider

package/src/utils/logger.js

@@ -0,0 +1,20 @@
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }
+const level = LEVELS[process.env.LOG_LEVEL || 'info'] || 1
+
+function fmt(lvl, tag, msg, data) {
+  const ts = new Date().toISOString()
+  const base = `[${ts}] [${lvl.toUpperCase()}] [${tag}] ${msg}`
+  if (data !== undefined) console.log(base, typeof data === 'object' ? JSON.stringify(data) : data)
+  else console.log(base)
+}
+
+function createLogger(tag) {
+  return {
+    debug: (msg, data) => level <= 0 && fmt('debug', tag, msg, data),
+    info: (msg, data) => level <= 1 && fmt('info', tag, msg, data),
+    warn: (msg, data) => level <= 2 && fmt('warn', tag, msg, data),
+    error: (msg, data) => level <= 3 && fmt('error', tag, msg, data),
+  }
+}
+
+module.exports = { createLogger }

package/src/utils/metrics.js

@@ -0,0 +1,96 @@
+const { createLogger } = require('./logger')
+const log = createLogger('metrics')
+
+/**
+ * Metrics — Tracks agent performance across games.
+ */
+class Metrics {
+  constructor(store) {
+    this.store = store
+    this._current = {
+      gamesPlayed: 0,
+      wins: 0,
+      podiums: 0, // top 3
+      totalScore: 0,
+      totalRank: 0,
+      kills: 0,
+      modelVersion: 'rule-based',
+    }
+  }
+
+  load(game) {
+    if (!this.store) return
+
+    try {
+      const sessions = this.store.db.prepare(`
+        SELECT result FROM game_sessions
+        WHERE game = ? AND result IS NOT NULL
+      `).all(game)
+
+      for (const s of sessions) {
+        const r = JSON.parse(s.result || '{}')
+        this._record(r)
+      }
+
+      log.info(`Loaded metrics: ${this._current.gamesPlayed} games, ` +
+        `win rate ${this.winRate}%, avg rank ${this.avgRank}`)
+    } catch (err) {
+      log.warn('Failed to load metrics', err.message)
+    }
+  }
+
+  record(result) {
+    this._record(result)
+    this._logSummary()
+  }
+
+  _record(result) {
+    if (!result) return
+    this._current.gamesPlayed++
+    if (result.placement === 1) this._current.wins++
+    if (result.placement <= 3) this._current.podiums++
+    this._current.totalScore += result.score || 0
+    this._current.totalRank += result.placement || 8
+    this._current.kills += result.kills || 0
+  }
+
+  get gamesPlayed() { return this._current.gamesPlayed }
+  get winRate() {
+    if (this._current.gamesPlayed === 0) return '0.0'
+    return (this._current.wins / this._current.gamesPlayed * 100).toFixed(1)
+  }
+  get podiumRate() {
+    if (this._current.gamesPlayed === 0) return '0.0'
+    return (this._current.podiums / this._current.gamesPlayed * 100).toFixed(1)
+  }
+  get avgRank() {
+    if (this._current.gamesPlayed === 0) return '0.0'
+    return (this._current.totalRank / this._current.gamesPlayed).toFixed(2)
+  }
+  get avgScore() {
+    if (this._current.gamesPlayed === 0) return '0'
+    return (this._current.totalScore / this._current.gamesPlayed).toFixed(0)
+  }
+  get totalKills() { return this._current.kills }
+
+  _logSummary() {
+    log.info(
+      `[${this._current.gamesPlayed} games] ` +
+      `win: ${this.winRate}% | top3: ${this.podiumRate}% | ` +
+      `avgRank: ${this.avgRank} | avgScore: ${this.avgScore} | kills: ${this.totalKills}`
+    )
+  }
+
+  toJSON() {
+    return {
+      gamesPlayed: this.gamesPlayed,
+      winRate: this.winRate + '%',
+      podiumRate: this.podiumRate + '%',
+      avgRank: this.avgRank,
+      avgScore: this.avgScore,
+      totalKills: this.totalKills,
+    }
+  }
+}
+
+module.exports = Metrics

package/src/utils/retry.js

@@ -0,0 +1,21 @@
+const { createLogger } = require('./logger')
+const log = createLogger('retry')
+
+async function retry(fn, { maxAttempts = 3, delayMs = 1000, backoff = 2 } = {}) {
+  let lastErr
+  for (let i = 1; i <= maxAttempts; i++) {
+    try {
+      return await fn()
+    } catch (err) {
+      lastErr = err
+      if (i < maxAttempts) {
+        const wait = delayMs * Math.pow(backoff, i - 1)
+        log.warn(`Attempt ${i}/${maxAttempts} failed, retrying in ${wait}ms`, err.message)
+        await new Promise(r => setTimeout(r, wait))
+      }
+    }
+  }
+  throw lastErr
+}
+
+module.exports = { retry }

package/training/models/gc_strategy_net.py

@@ -0,0 +1,46 @@
+"""
+GC Strategy Network - Predicts optimal strategy from game state features.
+
+Input: 120-dim move feature vector (same as featureBuilder)
+Output: 7 classes (3 modes × 2 target priorities + 1 flee flag)
+
+Simplified output mapping:
+  0: aggressive + nearest
+  1: aggressive + lowest_hp
+  2: balanced + nearest
+  3: balanced + lowest_hp
+  4: defensive + nearest
+  5: defensive + lowest_hp
+  6: flee (defensive + high flee_threshold)
+"""
+
+import torch
+import torch.nn as nn
+
+
+class GcStrategyNet(nn.Module):
+    def __init__(self, input_dim=120, hidden1=64, hidden2=32, output_dim=7):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden1),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(hidden1, hidden2),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(hidden2, output_dim),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+STRATEGY_MAP = [
+    {"mode": "aggressive", "target_priority": "nearest", "flee_threshold": 10},
+    {"mode": "aggressive", "target_priority": "lowest_hp", "flee_threshold": 10},
+    {"mode": "balanced", "target_priority": "nearest", "flee_threshold": 15},
+    {"mode": "balanced", "target_priority": "lowest_hp", "flee_threshold": 15},
+    {"mode": "defensive", "target_priority": "nearest", "flee_threshold": 20},
+    {"mode": "defensive", "target_priority": "lowest_hp", "flee_threshold": 20},
+    {"mode": "defensive", "target_priority": "nearest", "flee_threshold": 30},
+]

package/training/requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.0.0
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+onnx>=1.14.0
+onnxruntime>=1.17.0