Lck Analytics

league,matchid,date,patch,side,teamname,opponentteam,playername,position,champion,opponentchampion,result,gd15,csd15,xpd15,drg,bn,blindpick,counterpick
LCK,match-1,2026-04-01,16.6.753.8272,blue,Hanwha Life Esports,T1,HLE Zeus,top,Aatrox,Gnar,win,1200,18,340,100,100,0,1
LCK,match-1,2026-04-01,16.6.753.8272,blue,Hanwha Life Esports,T1,HLE Peanut,jungle,Vi,Sejuani,win,800,5,280,100,100,1,0
LCK,match-1,2026-04-01,16.6.753.8272,red,T1,Hanwha Life Esports,T1 Doran,top,Gnar,Aatrox,loss,-1200,-18,-340,0,0,1,0
LCK,match-1,2026-04-01,16.6.753.8272,red,T1,Hanwha Life Esports,T1 Oner,jungle,Sejuani,Vi,loss,-800,-5,-280,0,0,0,1

const fs = require("node:fs");
const path = require("node:path");
const { pathToFileURL } = require("node:url");

async function loadLckResults() {
  const candidates = [];
  const packageNames = ["lck-analytics", "lck-results"];

  if (process.env.GLOBAL_NPM_ROOT) {
    for (const packageName of packageNames) {
      candidates.push(path.join(process.env.GLOBAL_NPM_ROOT, packageName, "src", "index.js"));
    }
  }

  try {
    const globalRoot = await detectGlobalNpmRoot();
    for (const packageName of packageNames) {
      candidates.push(path.join(globalRoot, packageName, "src", "index.js"));
    }
  } catch {
    // ignore detection failure and continue to local fallback
  }

  candidates.push(path.resolve(__dirname, "..", "..", "packages", "lck-analytics", "src", "index.js"));

  const entryPath = candidates.find((candidate) => fs.existsSync(candidate));
  if (!entryPath) {
    throw new Error("Could not find lck-analytics package. Install it globally with `npm install -g lck-analytics` or run from the k-skill repo.");
  }

  return import(pathToFileURL(entryPath).href);
}

function ensureDir(dirPath) {
  fs.mkdirSync(dirPath, { recursive: true });
}

function readJson(filePath, fallback = null) {
  if (!fs.existsSync(filePath)) {
    return fallback;
  }
  return JSON.parse(fs.readFileSync(filePath, "utf8"));
}

function writeJson(filePath, value) {
  ensureDir(path.dirname(filePath));
  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
}

function readText(filePath, fallback = "") {
  if (!fs.existsSync(filePath)) {
    return fallback;
  }
  return fs.readFileSync(filePath, "utf8");
}

function parseArgs(argv) {
  const args = {};
  for (let index = 0; index < argv.length; index += 1) {
    const token = argv[index];
    if (!token.startsWith("--")) {
      continue;
    }
    const key = token.slice(2);
    const next = argv[index + 1];
    if (!next || next.startsWith("--")) {
      args[key] = true;
      continue;
    }
    args[key] = next;
    index += 1;
  }
  return args;
}

function formatOutput(value) {
  return `${JSON.stringify(value, null, 2)}\n`;
}

function resolveCachePaths(baseDir) {
  return {
    root: baseDir,
    historical: path.join(baseDir, "historical-analysis.json"),
    live: path.join(baseDir, "live"),
    reports: path.join(baseDir, "reports"),
  };
}

async function detectGlobalNpmRoot() {
  const { execFileSync } = require("node:child_process");
  return execFileSync("npm", ["root", "-g"], { encoding: "utf8" }).trim();
}

module.exports = {
  ensureDir,
  formatOutput,
  loadLckResults,
  parseArgs,
  readJson,
  readText,
  resolveCachePaths,
  writeJson,
};

#!/usr/bin/env node
const fs = require("node:fs");
const path = require("node:path");
const {
  formatOutput,
  loadLckResults,
  parseArgs,
  readJson,
  resolveCachePaths,
  writeJson,
} = require("./_lib");

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const gameId = args.game;
  if (!gameId) {
    throw new Error("--game <gameId> is required");
  }

  const cacheDir = path.resolve(args.cache || path.join(process.cwd(), ".openclaw-lck-cache"));
  const paths = resolveCachePaths(cacheDir);
  const historicalWrapper = readJson(paths.historical, { data: {} });
  const pkg = await loadLckResults();

  const liveWindowPayload = args.window ? JSON.parse(fs.readFileSync(path.resolve(args.window), "utf8")) : undefined;
  const liveDetailsPayload = args.details ? JSON.parse(fs.readFileSync(path.resolve(args.details), "utf8")) : undefined;

  const analysis = await pkg.getGameAnalysis(gameId, {
    matchId: args.match,
    number: args.number ? Number(args.number) : null,
    state: args.state || undefined,
    historicalDataset: historicalWrapper.data,
    liveWindowPayload,
    liveDetailsPayload,
  });

  const reportFile = path.join(paths.reports, `game-${gameId}.json`);
  writeJson(reportFile, analysis);

  process.stdout.write(formatOutput({
    ok: true,
    reportFile,
    patch: analysis.patch,
    turningPoints: analysis.turningPoints,
    draftEdge: analysis.draft?.overallEdge || null,
  }));
}

main().catch((error) => {
  console.error(error.stack || String(error));
  process.exitCode = 1;
});

#!/usr/bin/env node
const path = require("node:path");
const {
  formatOutput,
  loadLckResults,
  parseArgs,
  readJson,
  resolveCachePaths,
  writeJson,
} = require("./_lib");

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const date = args.date;
  if (!date) {
    throw new Error("--date <YYYY-MM-DD> is required");
  }

  const cacheDir = path.resolve(args.cache || path.join(process.cwd(), ".openclaw-lck-cache"));
  const paths = resolveCachePaths(cacheDir);
  const historicalWrapper = readJson(paths.historical, { data: {} });
  const pkg = await loadLckResults();

  const analysis = await pkg.getMatchAnalysis(date, {
    team: args.team || undefined,
    historicalDataset: historicalWrapper.data,
  });

  const reportFile = path.join(paths.reports, `match-${date}${args.team ? `-${args.team}` : ""}.json`);
  writeJson(reportFile, analysis);

  process.stdout.write(formatOutput({
    ok: true,
    reportFile,
    queryDate: analysis.queryDate,
    matchCount: analysis.matches.length,
    teams: analysis.matches.map((match) => `${match.team1?.name} vs ${match.team2?.name}`),
  }));
}

main().catch((error) => {
  console.error(error.stack || String(error));
  process.exitCode = 1;
});

#!/usr/bin/env node
const path = require("node:path");
const {
  formatOutput,
  loadLckResults,
  parseArgs,
  readText,
  resolveCachePaths,
  writeJson,
} = require("./_lib");

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const cacheDir = path.resolve(args.cache || path.join(process.cwd(), ".openclaw-lck-cache"));
  const csvPath = args.csv ? path.resolve(args.csv) : path.join(__dirname, "..", "samples", "oracle-lck-sample.csv");
  const league = args.league || "LCK";
  const csvText = readText(csvPath);

  if (!csvText.trim()) {
    throw new Error(`CSV not found or empty: ${csvPath}`);
  }

  const pkg = await loadLckResults();
  const historical = pkg.buildHistoricalAnalytics(csvText, { league });
  const paths = resolveCachePaths(cacheDir);

  writeJson(paths.historical, {
    source: {
      type: "oracle-style-csv",
      csvPath,
      league,
      updatedAt: new Date().toISOString(),
    },
    data: historical,
  });

  process.stdout.write(formatOutput({
    ok: true,
    cacheFile: paths.historical,
    teamRatings: historical.teamPowerRatings.length,
    matchupStats: historical.matchupStats.length,
    synergyStats: historical.synergyStats.length,
    patchMeta: historical.patchMeta.length,
  }));
}

main().catch((error) => {
  console.error(error.stack || String(error));
  process.exitCode = 1;
});