satoai 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# Sato
+
+AI Coding Telemetry Dashboard. One command to capture and visualize OpenTelemetry data from Claude Code.
+
+Built with Next.js, Tailwind CSS v4, and Recharts.
+
+## Quick Start
+
+```bash
+npx sato
+```
+
+That's it. On first run, Sato automatically configures Claude Code to export telemetry, starts an embedded OTLP receiver on `:4318`, and opens the dashboard on `:3000`. No external collector needed.
+
+Open a new terminal and use Claude Code as usual — telemetry flows automatically.
+
+## Commands
+
+### `sato` / `sato start`
+
+Start the OTLP receiver and dashboard, then open the browser.
+
+```bash
+sato                         # defaults: dashboard :3000, OTLP :4318
+sato start --port 8080       # custom dashboard port
+sato start --otlp-port 4319  # custom OTLP port
+sato start --no-browser      # don't open browser
+```
+
+### `sato stop`
+
+Stop the running Sato instance.
+
+```bash
+sato stop
+```
+
+### `sato status`
+
+Show running state and data stats.
+
+```bash
+sato status
+```
+
+### `sato setup claude`
+
+Configure Claude Code to export telemetry. Appends env vars to your shell profile (`~/.zshrc` or `~/.bashrc`). Idempotent — safe to run multiple times.
+
+```bash
+sato setup claude
+```
+
+## How It Works
+
+1. `sato start` launches an embedded OTLP HTTP/JSON receiver on `:4318` and the Next.js dashboard on `:3000`
+2. Claude Code (with telemetry enabled) sends OpenTelemetry logs and metrics to the receiver
+3. The receiver appends data to `~/.sato/data/logs.json` and `~/.sato/data/metrics.json`
+4. The dashboard reads those files plus Claude Code session transcripts from `~/.claude/projects/`
+
+## Data
+
+All telemetry is stored locally in `~/.sato/data/`. Nothing is sent to external services.
+
+- `~/.sato/data/logs.json` — OTLP log records
+- `~/.sato/data/metrics.json` — OTLP metric records
+- `~/.sato/classification-cache.json` — AI classification cache
+- `~/.sato/sato.pid` — PID file for the running instance
+
+## Features
+
+- **Summary cards** — Total spend, sessions, tokens, prompts, avg latency, cache hit rate
+- **Cost chart** — Cumulative spend over time
+- **Token chart** — Input/output/cache breakdown per request
+- **Model distribution** — Usage across Claude models
+- **Session explorer** — Expandable session timeline with per-prompt detail, tool calls, and assistant messages
+- **AI classification** — Automatic categorization of prompts (requires `ANTHROPIC_API_KEY` env var)
+- **Request table** — Sortable, paginated table of all API calls
+
+## Development
+
+```bash
+git clone https://github.com/SatoAI-co/Sato.git
+cd Sato
+npm install
+npm run dev         # Next.js dev server on :3000
+npm run build:cli   # compile CLI to dist/cli/
+```
+
+## Prerequisites
+
+- **Node.js** 18+
+- **Claude Code** CLI (`npm install -g @anthropic-ai/claude-code`)
+- **Anthropic API key** (optional, for AI session classification)

package/dist/cli/commands/daemon.js

@@ -0,0 +1,35 @@
+import { createOtlpReceiver } from "../lib/otlp-receiver.js";
+import { writePid, readPid, isRunning, removePid } from "../lib/process-manager.js";
+export async function daemonCommand(options) {
+    const otlpPort = parseInt(options.otlpPort, 10);
+    // Check if already running
+    const existing = readPid();
+    if (existing && isRunning(existing.pid)) {
+        // Another instance is already running — exit silently
+        process.exit(0);
+    }
+    // Clean stale PID
+    if (existing)
+        removePid();
+    // Start OTLP receiver only
+    const otlpServer = createOtlpReceiver(otlpPort);
+    await new Promise((resolve, reject) => {
+        otlpServer.on("error", reject);
+        otlpServer.listen(otlpPort, () => resolve());
+    });
+    // Write PID file in daemon mode
+    writePid({
+        pid: process.pid,
+        otlpPort,
+        startedAt: new Date().toISOString(),
+        mode: "daemon",
+    });
+    // Handle shutdown
+    const cleanup = () => {
+        otlpServer.close();
+        removePid();
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+}

package/dist/cli/commands/setup/claude.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { detectShellProfile, hasSatoConfig, injectEnvVars } from "../../lib/shell-config.js";
+export function setupClaudeCommand() {
+    const profilePath = detectShellProfile();
+    if (!profilePath) {
+        console.error(chalk.red("Could not detect shell profile."), "Manually add the Sato env vars to your shell config.");
+        printManualInstructions();
+        process.exit(1);
+    }
+    if (hasSatoConfig(profilePath)) {
+        console.log(chalk.green("✓"), `Sato env vars already present in ${chalk.dim(profilePath)}`);
+        console.log(chalk.dim("  To update, remove the existing block and re-run this command."));
+        return;
+    }
+    injectEnvVars(profilePath);
+    console.log(chalk.green("✓"), `Added Sato env vars to ${chalk.bold(profilePath)}`);
+    console.log();
+    console.log(`  Reload your shell to apply:`);
+    console.log(chalk.cyan(`    source ${profilePath}`));
+    console.log();
+    console.log(`  Then start Sato and use Claude Code as usual:`);
+    console.log(chalk.cyan(`    sato start`));
+    console.log(chalk.cyan(`    claude`));
+    console.log();
+}
+function printManualInstructions() {
+    console.log();
+    console.log("  Add these to your shell profile:");
+    console.log();
+    console.log(chalk.dim("  # Sato - AI Coding Telemetry"));
+    console.log(chalk.dim("  export CLAUDE_CODE_ENABLE_TELEMETRY=1"));
+    console.log(chalk.dim("  export OTEL_LOG_USER_PROMPTS=1"));
+    console.log(chalk.dim("  export OTEL_LOGS_EXPORTER=otlp"));
+    console.log(chalk.dim("  export OTEL_METRICS_EXPORTER=otlp"));
+    console.log(chalk.dim('  export OTEL_EXPORTER_OTLP_PROTOCOL=http/json'));
+    console.log(chalk.dim("  export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318"));
+    console.log(chalk.dim("  export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=delta"));
+    console.log(chalk.dim("  # End Sato"));
+    console.log();
+}

package/dist/cli/commands/setup/index.js

@@ -0,0 +1,10 @@
+import { setupClaudeCommand } from "./claude.js";
+export function registerSetupCommand(program) {
+    const setup = program
+        .command("setup")
+        .description("Configure AI coding tools to send telemetry to Sato");
+    setup
+        .command("claude")
+        .description("Configure Claude Code to export telemetry via OTLP")
+        .action(setupClaudeCommand);
+}

package/dist/cli/commands/start.js

@@ -0,0 +1,63 @@
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { createOtlpReceiver } from "../lib/otlp-receiver.js";
+import { writePid, readPid, isRunning, removePid } from "../lib/process-manager.js";
+import { printBanner } from "../lib/banner.js";
+import { detectShellProfile, hasSatoConfig, injectEnvVars } from "../lib/shell-config.js";
+import { installLaunchAgent, isLaunchAgentInstalled } from "../lib/launchd.js";
+export async function startCommand(options) {
+    const otlpPort = parseInt(options.otlpPort, 10);
+    // Auto-setup: configure Claude Code env vars if not already done
+    const profilePath = detectShellProfile();
+    if (profilePath && !hasSatoConfig(profilePath)) {
+        injectEnvVars(profilePath);
+        console.log(chalk.green("✓"), `Configured Claude Code telemetry in ${chalk.dim(profilePath)}`);
+        console.log();
+        console.log(chalk.yellow("⚠"), chalk.bold("Open a new terminal window before using Claude Code."));
+        console.log(chalk.dim("  The telemetry env vars won't take effect in this terminal session."));
+        console.log(chalk.dim(`  Alternatively, run: source ${profilePath}`));
+        console.log();
+    }
+    // Auto-install LaunchAgent on macOS (so daemon starts on login)
+    if (process.platform === "darwin" && !isLaunchAgentInstalled()) {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const cliPath = resolve(__dirname, "..", "index.js");
+        installLaunchAgent(otlpPort, cliPath);
+        console.log(chalk.green("✓"), "Installed LaunchAgent — OTLP receiver will auto-start on login");
+    }
+    // Check if already running
+    const existing = readPid();
+    if (existing && isRunning(existing.pid)) {
+        console.log(chalk.yellow(`Sato is already running (PID ${existing.pid}).`));
+        return;
+    }
+    // Clean stale PID if process is dead
+    if (existing && !isRunning(existing.pid)) {
+        removePid();
+    }
+    // Start OTLP receiver
+    const otlpServer = createOtlpReceiver(otlpPort);
+    await new Promise((resolve, reject) => {
+        otlpServer.on("error", reject);
+        otlpServer.listen(otlpPort, () => resolve());
+    });
+    console.log(chalk.green("✓"), `OTLP receiver listening on :${otlpPort}`);
+    // Write PID file
+    writePid({
+        pid: process.pid,
+        otlpPort,
+        startedAt: new Date().toISOString(),
+        mode: "receiver",
+    });
+    printBanner(otlpPort);
+    // Handle shutdown
+    const cleanup = () => {
+        console.log(chalk.dim("\nShutting down..."));
+        otlpServer.close();
+        removePid();
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+}

package/dist/cli/commands/status.js

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+import { readPid, isRunning } from "../lib/process-manager.js";
+import { DATA_DIR, SATOAI_INGEST_URL } from "../lib/paths.js";
+import { isLaunchAgentInstalled } from "../lib/launchd.js";
+export function statusCommand() {
+    const info = readPid();
+    console.log(chalk.bold("\n  Sato Status\n"));
+    if (info && isRunning(info.pid)) {
+        console.log(`  ${chalk.green("●")} Running (PID ${info.pid})`);
+        console.log(`    OTLP:       http://localhost:${info.otlpPort}`);
+        console.log(`    Forwarding: ${SATOAI_INGEST_URL}/api/ingest`);
+        console.log(`    Started:    ${info.startedAt}`);
+    }
+    else {
+        console.log(`  ${chalk.red("●")} Not running`);
+        if (info) {
+            console.log(chalk.dim("    (Stale PID file found — run 'sato start' to restart)"));
+        }
+    }
+    console.log(chalk.bold("\n  LaunchAgent\n"));
+    if (isLaunchAgentInstalled()) {
+        console.log(`  ${chalk.green("●")} Installed — daemon auto-starts on login`);
+    }
+    else {
+        console.log(`  ${chalk.dim("○")} Not installed — run 'sato start' to install`);
+    }
+    console.log(chalk.bold("\n  Dashboard\n"));
+    console.log(`    ${chalk.underline(SATOAI_INGEST_URL)}`);
+    console.log(chalk.bold("\n  Data\n"));
+    console.log(`    Directory:  ${DATA_DIR}`);
+    console.log();
+}

package/dist/cli/commands/stop.js

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+import { readPid, isRunning, removePid } from "../lib/process-manager.js";
+import { uninstallLaunchAgent, isLaunchAgentInstalled } from "../lib/launchd.js";
+export function stopCommand(options) {
+    const info = readPid();
+    if (!info) {
+        console.log(chalk.yellow("Sato is not running (no PID file found)."));
+    }
+    else if (!isRunning(info.pid)) {
+        console.log(chalk.yellow(`Sato process (PID ${info.pid}) is no longer running. Cleaning up.`));
+        removePid();
+    }
+    else {
+        try {
+            process.kill(info.pid, "SIGTERM");
+            console.log(chalk.green("✓"), `Stopped Sato (PID ${info.pid})`);
+            removePid();
+        }
+        catch (err) {
+            console.error(chalk.red(`Failed to stop process ${info.pid}:`), err);
+        }
+    }
+    if (options.uninstall) {
+        if (isLaunchAgentInstalled()) {
+            uninstallLaunchAgent();
+            console.log(chalk.green("✓"), "Removed LaunchAgent — daemon will no longer auto-start on login");
+        }
+        else {
+            console.log(chalk.dim("  LaunchAgent was not installed, nothing to remove."));
+        }
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { startCommand } from "./commands/start.js";
+import { stopCommand } from "./commands/stop.js";
+import { statusCommand } from "./commands/status.js";
+import { daemonCommand } from "./commands/daemon.js";
+import { registerSetupCommand } from "./commands/setup/index.js";
+const program = new Command();
+program
+    .name("sato")
+    .description("AI Coding Telemetry Collector")
+    .version("0.1.0");
+program
+    .command("start", { isDefault: true })
+    .description("Start the OTLP receiver and forward data to satoai.co")
+    .option("--otlp-port <port>", "OTLP receiver port", "4318")
+    .action(startCommand);
+program
+    .command("stop")
+    .description("Stop the running Sato instance")
+    .option("--uninstall", "Also remove the LaunchAgent (disables auto-start on login)")
+    .action(stopCommand);
+program
+    .command("status")
+    .description("Show Sato running state")
+    .action(statusCommand);
+program
+    .command("daemon")
+    .description("Start OTLP receiver only (used by LaunchAgent)")
+    .option("--otlp-port <port>", "OTLP receiver port", "4318")
+    .action(daemonCommand);
+registerSetupCommand(program);
+program.parse();

package/dist/cli/lib/banner.js

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import { SATOAI_INGEST_URL } from "./paths.js";
+export function printBanner(otlpPort) {
+    const banner = `
+${chalk.bold.cyan("  ███████╗ █████╗ ████████╗ ██████╗ ")}
+${chalk.bold.cyan("  ██╔════╝██╔══██╗╚══██╔══╝██╔═══██╗")}
+${chalk.bold.cyan("  ███████╗███████║   ██║   ██║   ██║")}
+${chalk.bold.cyan("  ╚════██║██╔══██║   ██║   ██║   ██║")}
+${chalk.bold.cyan("  ███████║██║  ██║   ██║   ╚██████╔╝")}
+${chalk.bold.cyan("  ╚══════╝╚═╝  ╚═╝   ╚═╝    ╚═════╝ ")}
+
+  ${chalk.dim("AI Coding Telemetry Collector")}
+
+  ${chalk.green("▸")} Dashboard     ${chalk.underline(`${SATOAI_INGEST_URL}`)}
+  ${chalk.green("▸")} OTLP receiver ${chalk.dim(`http://localhost:${otlpPort}`)}
+  ${chalk.green("▸")} Data dir      ${chalk.dim("~/.sato/data/")}
+
+  ${chalk.dim("Press Ctrl+C to stop")}
+`;
+    console.log(banner);
+}

package/dist/cli/lib/launchd.js

@@ -0,0 +1,59 @@
+import { existsSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { execSync } from "child_process";
+import { LAUNCHD_PLIST, LOG_DIR } from "./paths.js";
+function buildPlist(cliPath, otlpPort) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>co.sato.receiver</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${cliPath}</string>
+    <string>daemon</string>
+    <string>--otlp-port</string>
+    <string>${otlpPort}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_DIR}/daemon.stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_DIR}/daemon.stderr.log</string>
+</dict>
+</plist>`;
+}
+export function installLaunchAgent(otlpPort, cliPath) {
+    mkdirSync(dirname(LAUNCHD_PLIST), { recursive: true });
+    mkdirSync(LOG_DIR, { recursive: true });
+    const plist = buildPlist(cliPath, otlpPort);
+    writeFileSync(LAUNCHD_PLIST, plist);
+    try {
+        execSync(`launchctl load -w "${LAUNCHD_PLIST}"`, { stdio: "pipe" });
+    }
+    catch {
+        // May already be loaded
+    }
+}
+export function uninstallLaunchAgent() {
+    try {
+        execSync(`launchctl unload "${LAUNCHD_PLIST}"`, { stdio: "pipe" });
+    }
+    catch {
+        // May not be loaded
+    }
+    try {
+        unlinkSync(LAUNCHD_PLIST);
+    }
+    catch {
+        // Already gone
+    }
+}
+export function isLaunchAgentInstalled() {
+    return existsSync(LAUNCHD_PLIST);
+}

package/dist/cli/lib/otlp-receiver.js

@@ -0,0 +1,71 @@
+import http from "http";
+import { mkdirSync, appendFileSync } from "fs";
+import { dirname } from "path";
+import { LOGS_FILE, METRICS_FILE, SATOAI_INGEST_URL } from "./paths.js";
+const isRemote = !SATOAI_INGEST_URL.includes("localhost");
+function forwardToSatoai(endpoint, body) {
+    if (!isRemote)
+        return;
+    const url = `${SATOAI_INGEST_URL}/api/ingest${endpoint}`;
+    fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+    }).catch((err) => {
+        console.error(`[forward] Failed to forward to ${url}:`, err.message);
+    });
+}
+export function createOtlpReceiver(port) {
+    // Ensure data directory exists
+    mkdirSync(dirname(LOGS_FILE), { recursive: true });
+    const server = http.createServer((req, res) => {
+        // CORS headers for browser-based exporters
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.method !== "POST") {
+            res.writeHead(405);
+            res.end(JSON.stringify({ error: "Method not allowed" }));
+            return;
+        }
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            const body = Buffer.concat(chunks).toString("utf-8");
+            let targetFile = null;
+            let forwardEndpoint = null;
+            if (req.url === "/v1/logs") {
+                targetFile = LOGS_FILE;
+                forwardEndpoint = "/logs";
+            }
+            else if (req.url === "/v1/metrics") {
+                targetFile = METRICS_FILE;
+                forwardEndpoint = "/metrics";
+            }
+            if (!targetFile) {
+                // Accept any OTLP endpoint gracefully (traces, etc.)
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end("{}");
+                return;
+            }
+            try {
+                appendFileSync(targetFile, body + "\n");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end("{}");
+                // Fire-and-forget forward (only when pointing at a remote server)
+                forwardToSatoai(forwardEndpoint, body);
+            }
+            catch (err) {
+                console.error(`Failed to write to ${targetFile}:`, err);
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Failed to persist data" }));
+            }
+        });
+    });
+    return server;
+}

package/dist/cli/lib/paths.js

@@ -0,0 +1,10 @@
+import { homedir } from "os";
+import { join } from "path";
+export const SATO_HOME = join(homedir(), ".sato");
+export const DATA_DIR = join(SATO_HOME, "data");
+export const LOG_DIR = join(SATO_HOME, "logs");
+export const PID_FILE = join(SATO_HOME, "sato.pid");
+export const LOGS_FILE = join(DATA_DIR, "logs.json");
+export const METRICS_FILE = join(DATA_DIR, "metrics.json");
+export const LAUNCHD_PLIST = join(homedir(), "Library", "LaunchAgents", "co.sato.receiver.plist");
+export const SATOAI_INGEST_URL = process.env.SATO_INGEST_URL || "http://localhost:3000";

package/dist/cli/lib/process-manager.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { PID_FILE } from "./paths.js";
+export function writePid(info) {
+    mkdirSync(dirname(PID_FILE), { recursive: true });
+    writeFileSync(PID_FILE, JSON.stringify(info, null, 2));
+}
+export function readPid() {
+    try {
+        if (!existsSync(PID_FILE))
+            return null;
+        return JSON.parse(readFileSync(PID_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function removePid() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch {
+        // Already gone
+    }
+}
+export function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/lib/shell-config.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync, appendFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const SENTINEL_START = "# Sato - AI Coding Telemetry";
+const SENTINEL_END = "# End Sato";
+const ENV_BLOCK = `
+${SENTINEL_START}
+export CLAUDE_CODE_ENABLE_TELEMETRY=1
+export OTEL_LOG_USER_PROMPTS=1
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=delta
+${SENTINEL_END}
+`;
+export function detectShellProfile() {
+    const home = homedir();
+    const shell = process.env.SHELL ?? "";
+    if (shell.includes("zsh")) {
+        const zshrc = join(home, ".zshrc");
+        if (existsSync(zshrc))
+            return zshrc;
+        return zshrc; // Create it if needed
+    }
+    if (shell.includes("bash")) {
+        // Prefer .bashrc, fallback to .bash_profile
+        const bashrc = join(home, ".bashrc");
+        if (existsSync(bashrc))
+            return bashrc;
+        const profile = join(home, ".bash_profile");
+        if (existsSync(profile))
+            return profile;
+        return bashrc;
+    }
+    // Fallback: try common profile files
+    for (const name of [".zshrc", ".bashrc", ".bash_profile", ".profile"]) {
+        const p = join(home, name);
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+export function hasSatoConfig(profilePath) {
+    try {
+        const content = readFileSync(profilePath, "utf-8");
+        return content.includes(SENTINEL_START);
+    }
+    catch {
+        return false;
+    }
+}
+export function injectEnvVars(profilePath) {
+    appendFileSync(profilePath, ENV_BLOCK);
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "satoai",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "AI Coding Telemetry Collector — captures OpenTelemetry data from Claude Code and forwards to satoai.co",
+  "bin": {
+    "sato": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "build:cli": "tsc -p tsconfig.cli.json",
+    "prepack": "npm run build:cli",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "next": "16.1.6",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "recharts": "^3.7.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.1.6",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}