@vatvaghool/create-ipl-dashboard 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# create-ipl-dashboard
+
+Scaffold a full-featured IPL fantasy cricket dashboard in seconds.
+
+```bash
+npx create-ipl-dashboard my-league
+```
+
+Follow the prompts to enter your MongoDB URI, fantasy league URL, and team names — then get a ready-to-run Next.js dashboard with standings charts, performance trackers, AI roasts, and more.
+
+## Usage
+
+```bash
+npx create-ipl-dashboard [project-name] [options]
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--help`, `-h` | Show help message |
+| `--scrape` | Auto-detect team names from the league URL |
+| `--skip-install` | Skip `npm install` (useful for testing) |
+
+### Interactive prompts
+
+| Prompt | Description |
+|--------|-------------|
+| MongoDB URI | Your MongoDB connection string (or leave blank for file-based fallback) |
+| League URL | The fantasy.iplt20.com league page URL |
+| Teams | Team names (and optional owners) in your league |
+
+If `--scrape` is provided, the CLI attempts to extract team names from the league page HTML. If that fails, it falls back to manual entry.
+
+## What you get
+
+A full Next.js 16 project with:
+
+- **Leaderboard dashboard** — live standings with rank movements and point gaps
+- **Performance charts** — Recharts line charts tracking every team's trajectory
+- **Captain board** — captain/vice-captain picks per team
+- **Match scrubber** — interactive timeline through match history
+- **AI roasting** — generated commentary in multiple languages
+- **Stock ticker** — fantasy stocks with sparklines
+- **Live updates** — bookmarklet or Playwright scraper for live sync
+- **MongoDB persistence** — optional, with file-based fallback for dev
+
+## Quick start after scaffold
+
+```bash
+cd my-league
+
+# Start the dev server
+npm run dev:simple
+
+# Capture auth state for scrapers (one-time setup)
+npm run capture:ipl-auth
+
+# Scrape live leaderboard data
+npm run sync:ipl
+```
+
+Open http://localhost:3000 to see your dashboard.
+
+## How it works
+
+The CLI:
+
+1. Copies a pre-built Next.js app template
+2. Writes your `.env` with MongoDB URI and league URL
+3. Generates `app/data/teams.ts` with your team roster
+4. Creates a placeholder `app/data/match-points.ts` (auto-populates as you sync)
+5. Installs dependencies
+
+The template includes all dashboard components, API endpoints, scrapers, and tests from the [ipl-dashboard](https://github.com/anomalyco/ipl-dashboard) project.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@vatvaghool/create-ipl-dashboard",
+  "version": "0.1.0",
+  "description": "Scaffold an IPL fantasy cricket dashboard project",
+  "type": "module",
+  "bin": {
+    "create-ipl-dashboard": "./src/index.mjs"
+  },
+  "files": [
+    "src",
+    "template"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate:template": "node src/generate-template.mjs"
+  },
+  "keywords": [
+    "ipl",
+    "fantasy-cricket",
+    "dashboard",
+    "scaffold",
+    "create-app"
+  ],
+  "license": "MIT"
+}

package/src/generate-template.mjs

@@ -0,0 +1,73 @@
+import { cp, readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, "..");
+const TEMPLATE_DIR = join(PACKAGE_ROOT, "template");
+const MONOREPO_ROOT = join(PACKAGE_ROOT, "..", "..");
+
+const SKIP_PATTERNS = [
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  "packages/create-ipl-dashboard",
+  "ipl-auth.json",
+  ".env",
+  ".env.example",
+  "live-snapshot.json",
+  "packages/ipl-dashboard-utils/dist",
+  "next-env.d.ts",
+  "tsconfig.tsbuildinfo",
+];
+
+
+async function getAllFiles(dir) {
+  const entries = [];
+  const { readdir, stat } = await import("node:fs/promises");
+  async function walk(current) {
+    const items = await readdir(current, { withFileTypes: true });
+    for (const item of items) {
+      const full = join(current, item.name);
+      const rel = relative(MONOREPO_ROOT, full);
+      if (SKIP_PATTERNS.some((p) => rel === p || rel.startsWith(p + "/") || item.name === p)) continue;
+      if (item.name.startsWith(".") && item.name !== ".env.example" && item.name !== ".dockerignore" && item.name !== ".gitignore") continue;
+      if (item.isDirectory()) {
+        await walk(full);
+      } else {
+        entries.push(rel);
+      }
+    }
+  }
+  await walk(dir);
+  return entries;
+}
+
+async function generateTemplate() {
+  console.log("Generating template from monorepo...");
+
+  if (existsSync(TEMPLATE_DIR)) {
+    const { rm } = await import("node:fs/promises");
+    await rm(TEMPLATE_DIR, { recursive: true, force: true });
+  }
+
+  const files = await getAllFiles(MONOREPO_ROOT);
+  for (const file of files) {
+    const src = join(MONOREPO_ROOT, file);
+    const dest = join(TEMPLATE_DIR, file);
+    await mkdir(dirname(dest), { recursive: true });
+    await cp(src, dest);
+    console.log(`  ${file}`);
+  }
+
+  // Write a note about generated files
+  console.log("\nTemplate generated at:", TEMPLATE_DIR);
+  console.log(`Files: ${files.length}`);
+}
+
+generateTemplate().catch((err) => {
+  console.error("Failed to generate template:", err);
+  process.exit(1);
+});

package/src/index.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { getProjectName, getMongoUri, getLeagueUrl, getTeams, close } from "./prompts.mjs";
+import { scaffoldProject } from "./scaffold.mjs";
+import { scrapeTeamsFromUrl } from "./scraper.mjs";
+
+function printHelp(exitCode) {
+  console.log(`
+  create-ipl-dashboard [project-name] [options]
+
+  Scaffolds a new IPL fantasy cricket dashboard project.
+
+  Arguments:
+    project-name           Directory name to create (default: prompted)
+
+  Options:
+    --help, -h             Show this help message
+    --skip-install         Skip npm install after scaffolding
+    --scrape               Auto-detect team names from the league URL
+
+  Examples:
+    npx create-ipl-dashboard my-league
+    npx create-ipl-dashboard my-league --scrape
+    npx create-ipl-dashboard --skip-install
+`);
+  process.exit(exitCode);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const flags = { scrape: false, skipInstall: false, help: false };
+  const positional = [];
+
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") flags.help = true;
+    else if (arg === "--scrape") flags.scrape = true;
+    else if (arg === "--skip-install") flags.skipInstall = true;
+    else if (!arg.startsWith("--")) positional.push(arg);
+    else { console.error(`Unknown flag: ${arg}`); printHelp(1); }
+  }
+
+  if (flags.help) printHelp(0);
+
+  console.log("");
+  console.log("  🏏  IPL Fantasy Dashboard Scaffold");
+  console.log("");
+
+  const projectName = await getProjectName(positional);
+  const projectPath = join(process.cwd(), projectName);
+
+  if (existsSync(projectPath)) {
+    const { rm } = await import("node:fs/promises");
+    console.log(`  Directory "${projectName}" already exists. Removing...`);
+    await rm(projectPath, { recursive: true, force: true });
+  }
+
+  await mkdir(projectPath, { recursive: true });
+
+  const mongoUri = await getMongoUri();
+  const leagueUrl = await getLeagueUrl();
+  let teams;
+
+  if (flags.scrape && leagueUrl) {
+    console.log("  Attempting to scrape team names from league URL...");
+    teams = await scrapeTeamsFromUrl(leagueUrl);
+    if (teams && teams.length > 0) {
+      console.log(`  Found ${teams.length} team(s): ${teams.map((t) => t.name).join(", ")}`);
+    } else {
+      console.log("  Could not auto-detect teams. Enter them manually:");
+      teams = await getTeams();
+    }
+  } else {
+    teams = await getTeams();
+  }
+
+  close();
+
+  await scaffoldProject(projectPath, { mongoUri, leagueUrl, teams, skipInstall: flags.skipInstall });
+
+  console.log("");
+  console.log("  Next steps:");
+  console.log(`    cd ${projectName}`);
+  console.log("    npm run dev:simple");
+  console.log("");
+  console.log("  For live data sync, capture auth state:");
+  console.log(`    cd ${projectName}`);
+  console.log("    npm run capture:ipl-auth");
+  console.log("    npm run sync:ipl");
+  console.log("");
+}
+
+main().catch((err) => {
+  console.error("Scaffold failed:", err);
+  process.exit(1);
+});

package/src/prompts.mjs

@@ -0,0 +1,78 @@
+import { createInterface } from "node:readline";
+import { stdin as input, stdout as output, stdin } from "node:process";
+
+const isTTY = stdin.isTTY;
+
+let promptIndex = 0;
+let pipedLines = [];
+
+async function consumeAllLines() {
+  if (pipedLines.length > 0) return;
+  const rl = createInterface({ input });
+  for await (const line of rl) {
+    pipedLines.push(line);
+  }
+}
+
+function prompt(query) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input, output });
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+export async function getProjectName(args) {
+  if (args[0]) return args[0];
+  if (!isTTY) {
+    await consumeAllLines();
+    return pipedLines[promptIndex++] || "ipl-dashboard";
+  }
+  return (await prompt("Project name: ")).trim() || "ipl-dashboard";
+}
+
+export async function getMongoUri() {
+  if (!isTTY) {
+    await consumeAllLines();
+    return (pipedLines[promptIndex++] || "").trim();
+  }
+  return (await prompt("MongoDB URI (or press Enter to skip, can be set later): ")).trim();
+}
+
+export async function getLeagueUrl() {
+  if (!isTTY) {
+    await consumeAllLines();
+    return (pipedLines[promptIndex++] || "").trim();
+  }
+  return (await prompt("IPL fantasy league URL (or press Enter to skip, can be set later): ")).trim();
+}
+
+export async function getTeams() {
+  if (!isTTY) {
+    await consumeAllLines();
+    const count = Math.max(1, parseInt(pipedLines[promptIndex++], 10) || 9);
+    const teams = [];
+    for (let i = 0; i < count; i++) {
+      const line = pipedLines[promptIndex++] || "";
+      const parts = line.split(",").map((s) => s.trim());
+      teams.push({ id: i + 1, name: parts[0] || `Team ${i + 1}`, owner: parts[1] || parts[0] || `Team ${i + 1}` });
+    }
+    return teams;
+  }
+
+  const countAnswer = await prompt("How many teams in your league? (default: 9): ");
+  const count = Math.max(1, parseInt(countAnswer, 10) || 9);
+
+  console.log(`\nEnter ${count} team(s) — at minimum a name, optionally an owner:\n`);
+  const teams = [];
+  for (let i = 0; i < count; i++) {
+    const line = await prompt(`  Team ${i + 1} (Name or "Name,Owner"): `);
+    const parts = line.split(",").map((s) => s.trim());
+    teams.push({ id: i + 1, name: parts[0] || `Team ${i + 1}`, owner: parts[1] || parts[0] || `Team ${i + 1}` });
+  }
+  return teams;
+}
+
+export function close() {}

package/src/scaffold.mjs

@@ -0,0 +1,129 @@
+import { mkdir, writeFile, cp, readFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, "..");
+const TEMPLATE_DIR = join(PACKAGE_ROOT, "template");
+
+export async function scaffoldProject(projectPath, { mongoUri, leagueUrl, teams, skipInstall = false }) {
+  console.log(`\nCreating project at ${projectPath}...`);
+
+  await mkdir(projectPath, { recursive: true });
+
+  if (existsSync(TEMPLATE_DIR)) {
+    await cp(TEMPLATE_DIR, projectPath, { recursive: true });
+  } else {
+    console.log("  (no template directory found, generating from scratch)");
+  }
+
+  // Remove monorepo-specific files not needed in scaffolded project
+  for (const f of ["AGENTS.md", "tsconfig.tsbuildinfo", "tsconfig.buildinfo", "package-lock.json"]) {
+    try { await rm(join(projectPath, f)); } catch {}
+  }
+
+  await writeEnvFile(projectPath, { mongoUri, leagueUrl });
+  await writeTeamData(projectPath, teams);
+  await writeMatchPointsPlaceholder(projectPath);
+  await updatePackageJson(projectPath);
+
+  // Remove monorepo's live snapshots (they're specific to original league)
+  for (const f of ["app/api/ipl/live-snapshot.json", "app/api/ipl/transfers/live-snapshot.json"]) {
+    try { await rm(join(projectPath, f)); } catch {}
+  }
+
+  if (!skipInstall) {
+    console.log("  Running npm install...");
+    execSync("npm install", { cwd: projectPath, stdio: "inherit" });
+  } else {
+    console.log("  Skipping npm install (run manually: cd <project> && npm install)");
+  }
+
+  console.log("\n  Done! Your project is ready at:", projectPath);
+}
+
+async function writeEnvFile(projectPath, { mongoUri, leagueUrl }) {
+  const envPath = join(projectPath, ".env");
+  const lines = [
+    `MONGODB_URI=${mongoUri || ""}`,
+    `IPL_LEAGUE_URL=${leagueUrl || ""}`,
+    `IPL_POST_SECRET=`,
+    ``,
+    `IPL_API_BASE_URL=http://localhost:3000`,
+    `IPL_API_LOG=1`,
+    `IPL_API_LOG_PAYLOAD=0`,
+    `IPL_WRITE_SEED_DATA_FILE=1`,
+    ``,
+  ];
+  await writeFile(envPath, lines.join("\n"));
+}
+
+async function writeTeamData(projectPath, teams) {
+  const dir = join(projectPath, "app/data");
+  await mkdir(dir, { recursive: true });
+
+  const teamEntries = teams
+    .map(
+      (t) =>
+        `  { id: ${t.id}, name: "${t.name}", owner: "${t.owner}", fantasyNames: ["${t.name}"] }`,
+    )
+    .join(",\n");
+
+  const content = `export const TEAMS: { id: number; name: string; owner: string; fantasyNames: string[] }[] = [
+${teamEntries},
+];
+
+const byAlias = new Map<string, number>();
+for (const team of TEAMS) {
+  for (const alias of team.fantasyNames) {
+    byAlias.set(alias.toLowerCase().replace(/[^a-z0-9]/g, ""), team.id);
+  }
+}
+
+export const resolveTeamId = (name: string): number | undefined => {
+  const key = name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return byAlias.get(key);
+};
+
+export const TEAM_ALIAS_MAP: Record<string, string> = {};
+for (const team of TEAMS) {
+  for (const alias of team.fantasyNames) {
+    if (alias !== team.name) {
+      TEAM_ALIAS_MAP[alias] = team.name;
+    }
+  }
+}
+`;
+
+  await writeFile(join(dir, "teams.ts"), content);
+}
+
+async function writeMatchPointsPlaceholder(projectPath) {
+  const dir = join(projectPath, "app/data");
+  await mkdir(dir, { recursive: true });
+  const content = `export const MATCH_POINTS: { teamId: number; matchId: number; points: number }[] = [];
+
+// TODO: Populate with per-match point data.
+// The bookmarklet and Playwright scraper will auto-accumulate match data
+// as you sync live snapshots. You can also manually add rows here.
+//
+// Format:
+//   { teamId: 1, matchId: 1, points: 727 },
+//   { teamId: 2, matchId: 1, points: 650 },
+`;
+  await writeFile(join(dir, "match-points.ts"), content);
+}
+
+async function updatePackageJson(projectPath) {
+  const pkgPath = join(projectPath, "package.json");
+  try {
+    const raw = await readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    pkg.name = "ipl-dashboard";
+    pkg.private = false;
+    delete pkg.scripts?.["generate:template"];
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  } catch {}
+}

package/src/scraper.mjs

@@ -0,0 +1,79 @@
+import { get } from "node:https";
+
+const TIMEOUT_MS = 15000;
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    const req = get(url, { timeout: TIMEOUT_MS }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
+  });
+}
+
+function extractTeamsFromHtml(html) {
+  const names = new Set();
+
+  // Try to find team/player names in tables (fantasy site pattern)
+  const tableRowPatterns = [
+    /<tr[^>]*>[\s\S]*?<td[^>]*>[\s\S]*?<a[^>]*class="team-name"[^>]*>([^<]+)<\/a>/gi,
+    /<tr[^>]*>[\s\S]*?<td[^>]*class="[^"]*name[^"]*"[^>]*>([^<]+)<\/td>/gi,
+    /<td[^>]*class="[^"]*team[^"]*"[^>]*>([^<]+)<\/td>/gi,
+    /<div[^>]*class="[^"]*team-name[^"]*"[^>]*>([^<]+)<\/div>/gi,
+    /<span[^>]*class="[^"]*user-name[^"]*"[^>]*>([^<]+)<\/span>/gi,
+    /<div[^>]*class="[^"]*leaderboard-name[^"]*"[^>]*>([^<]+)<\/div>/gi,
+  ];
+
+  for (const pattern of tableRowPatterns) {
+    let match;
+    const re = new RegExp(pattern.source, "gi");
+    while ((match = re.exec(html)) !== null) {
+      const name = match[1].trim();
+      if (name.length > 1 && name.length < 80) {
+        names.add(name);
+      }
+    }
+  }
+
+  // Fallback: look for JSON-like data structures with team names
+  const jsonPatterns = [
+    /"teamName"\s*:\s*"([^"]+)"/g,
+    /"leaderName"\s*:\s*"([^"]+)"/g,
+    /"userName"\s*:\s*"([^"]+)"/g,
+    /"name"\s*:\s*"([^"]+)"[^}]*"points"/g,
+  ];
+
+  for (const pattern of jsonPatterns) {
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+      const name = match[1].trim();
+      if (name.length > 1 && name.length < 80 && !name.includes("/")) {
+        names.add(name);
+      }
+    }
+  }
+
+  return [...names].filter((n) => n.length > 1);
+}
+
+export async function scrapeTeamsFromUrl(url) {
+  try {
+    const html = await httpsGet(url);
+    const names = extractTeamsFromHtml(html);
+
+    if (names.length === 0) {
+      return null;
+    }
+
+    return names.map((name, i) => ({
+      id: i + 1,
+      name,
+      owner: name,
+    }));
+  } catch {
+    return null;
+  }
+}

package/template/.dockerignore

@@ -0,0 +1,13 @@
+.git
+.github
+.next
+node_modules
+coverage
+build
+.vercel
+.env*
+ipl-auth.json
+README.md
+app
+packages
+tests

package/template/AGENTS.md

@@ -0,0 +1,5 @@
+<!-- BEGIN:nextjs-agent-rules -->
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` before writing any code. Heed deprecation notices.
+<!-- END:nextjs-agent-rules -->

package/template/Dockerfile.sync

@@ -0,0 +1,14 @@
+FROM mcr.microsoft.com/playwright:v1.54.2-noble
+
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci
+RUN npm install --no-save playwright@1.54.2
+
+COPY scripts ./scripts
+
+ENV NODE_ENV=production
+ENV IPL_HEADLESS=1
+
+CMD ["npm", "run", "sync:cloud"]