@talocode/tradia 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# Tradia
+
+Local-first trading intelligence for prop firm traders.
+
+## Install
+
+```bash
+npx @talocode/tradia
+```
+
+Global install:
+
+```bash
+npm install -g @talocode/tradia
+tradia
+```
+
+## First run
+
+```bash
+tradia init
+tradia import ./trades.csv
+tradia stats
+tradia review week
+```
+
+## Storage
+
+Tradia stores data locally in `~/.tradia/`:
+
+- `config.json`
+- `trades.json`
+- `rules.json`
+- `reports/`
+
+No secrets, telemetry, broker connections, or paid APIs are required.
+
+## CSV import
+
+Tradia imports common broker CSV exports and normalizes them into a local trade journal. See `docs/CSV_IMPORT.md` for the supported column mapping and a sample file.
+
+## Commands
+
+```bash
+tradia
+tradia --version
+tradia --help
+tradia init
+tradia import ./trades.csv
+tradia trades list
+tradia stats
+tradia mistakes
+tradia risk
+tradia review week
+tradia plan tomorrow
+tradia rules set ftmo
+tradia rules status
+tradia doctor
+```
+
+## Limitations
+
+- CSV import first
+- No broker connection yet
+- No auto-trading
+- No financial advice
+- No paid APIs required
+- No cloud sync yet

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/lib/version.ts
+var PACKAGE_VERSION = "0.1.0";
+
+// src/lib/terminal.ts
+import readline from "readline";
+async function promptMenu(title, items) {
+  console.clear();
+  console.log(title);
+  console.log("");
+  items.forEach((item, index) => console.log(`${index + 1}. ${item}`));
+  const answer = await new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("\nSelect an option: ", (value) => {
+      rl.close();
+      resolve(value);
+    });
+  });
+  const choice = Number(answer);
+  return Number.isInteger(choice) && choice >= 1 && choice <= items.length ? choice - 1 : items.length - 1;
+}
+
+// src/lib/storage.ts
+import { mkdir, readFile, writeFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function getStoragePaths(baseDir = join(homedir(), ".tradia")) {
+  return {
+    baseDir,
+    configFile: join(baseDir, "config.json"),
+    tradesFile: join(baseDir, "trades.json"),
+    rulesFile: join(baseDir, "rules.json"),
+    reportsDir: join(baseDir, "reports")
+  };
+}
+async function ensureStorage(baseDir = getStoragePaths().baseDir) {
+  const paths = getStoragePaths(baseDir);
+  await mkdir(paths.baseDir, { recursive: true });
+  await mkdir(paths.reportsDir, { recursive: true });
+  return paths;
+}
+async function readJsonFile(path, fallback) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+async function writeJsonFile(path, value) {
+  await mkdir(join(path, ".."), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/csv-importer.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/lib/trade-normalizer.ts
+import crypto from "crypto";
+function firstValue(row, keys) {
+  for (const key of keys) {
+    const value = row[key];
+    if (value != null && String(value).trim() !== "") return String(value).trim();
+  }
+  return void 0;
+}
+function parseNumber(value) {
+  if (value == null) return void 0;
+  const normalized = value.replace(/[$,\s]/g, "");
+  if (normalized === "") return void 0;
+  const num = Number(normalized);
+  return Number.isFinite(num) ? num : void 0;
+}
+function parseDate(value) {
+  if (!value) return void 0;
+  const normalized = value.trim();
+  const time = new Date(normalized).getTime();
+  return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
+}
+function normalizeSide(value) {
+  const lower = value?.toLowerCase() ?? "";
+  if (["buy", "long", "b"].includes(lower)) return "buy";
+  if (["sell", "short", "s"].includes(lower)) return "sell";
+  return "unknown";
+}
+function normalizeTrade(row, fallbackIndex) {
+  const symbol = (firstValue(row, ["symbol", "pair", "instrument", "ticker"]) ?? "").toUpperCase();
+  const openedAt = parseDate(firstValue(row, ["date/time", "datetime", "date", "open time", "opened at"])) ?? parseDate(firstValue(row, ["close time", "closed at"])) ?? "";
+  const pnl = parseNumber(firstValue(row, ["profit/loss", "profit", "p/l", "pnl", "net pnl"])) ?? 0;
+  const commission = parseNumber(firstValue(row, ["commission"]));
+  const swap = parseNumber(firstValue(row, ["swap"]));
+  const netPnl = pnl + (commission ?? 0) + (swap ?? 0);
+  const id = firstValue(row, ["magic", "order id", "order_id", "ticket", "id"]) ?? crypto.createHash("sha1").update(JSON.stringify(row)).digest("hex");
+  if (!symbol || !openedAt || !Number.isFinite(netPnl)) return null;
+  const closedAt = parseDate(firstValue(row, ["close time", "closed at"]));
+  const entryPrice = parseNumber(firstValue(row, ["entry", "entry price", "open price"]));
+  const exitPrice = parseNumber(firstValue(row, ["exit", "exit price", "close price"]));
+  const lotSize = parseNumber(firstValue(row, ["size", "lot", "lot size", "volume"]));
+  const accountBalance = parseNumber(firstValue(row, ["balance", "account balance"]));
+  const durationMinutes = parseNumber(firstValue(row, ["duration", "duration minutes"]));
+  return {
+    id: `${id}-${fallbackIndex}`,
+    openedAt,
+    closedAt,
+    symbol,
+    side: normalizeSide(firstValue(row, ["side/type", "side", "type"])),
+    lotSize,
+    entryPrice,
+    exitPrice,
+    pnl,
+    commission,
+    swap,
+    netPnl,
+    accountBalance,
+    durationMinutes,
+    source: "csv",
+    raw: row
+  };
+}
+
+// src/lib/csv-importer.ts
+function splitCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (char === '"') {
+      if (quoted && line[i + 1] === '"') {
+        current += '"';
+        i += 1;
+      } else {
+        quoted = !quoted;
+      }
+      continue;
+    }
+    if (char === "," && !quoted) {
+      cells.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  cells.push(current.trim());
+  return cells;
+}
+function parseCsv(content) {
+  const lines = content.split(/\r?\n/).filter((line) => line.trim() !== "");
+  if (lines.length === 0) return [];
+  const headers = splitCsvLine(lines[0]).map((header) => header.trim().toLowerCase());
+  return lines.slice(1).map((line) => {
+    const values = splitCsvLine(line);
+    const row = {};
+    headers.forEach((header, index) => {
+      row[header] = values[index] ?? "";
+    });
+    return row;
+  });
+}
+async function importTradesFromCsv(path) {
+  const content = await readFile2(path, "utf8");
+  const rows = parseCsv(content);
+  const warnings = [];
+  const trades = [];
+  rows.forEach((row, index) => {
+    const trade = normalizeTrade(row, index);
+    if (!trade) {
+      warnings.push({ row: index + 2, message: "Invalid row skipped" });
+      return;
+    }
+    trades.push(trade);
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const trade of trades) {
+    if (seen.has(trade.id)) continue;
+    seen.add(trade.id);
+    deduped.push(trade);
+  }
+  return { trades: deduped, warnings };
+}
+
+// src/commands/import.ts
+async function runImport(csvPath) {
+  const { tradesFile } = await ensureStorage();
+  const existing = await readJsonFile(tradesFile, []);
+  const { trades, warnings } = await importTradesFromCsv(csvPath);
+  const merged = [...existing];
+  const seen = new Set(existing.map((trade) => trade.id));
+  for (const trade of trades) {
+    if (seen.has(trade.id)) continue;
+    seen.add(trade.id);
+    merged.push(trade);
+  }
+  await writeJsonFile(tradesFile, merged);
+  return [
+    `Imported ${trades.length} trades from ${csvPath}.`,
+    `Stored ${merged.length} total trades.`,
+    warnings.length ? `${warnings.length} invalid rows skipped.` : "No invalid rows skipped."
+  ].join("\n");
+}
+
+// src/lib/analytics.ts
+function mean(values) {
+  if (!values.length) return void 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function streak(values, positive) {
+  let best = 0;
+  let current = 0;
+  for (const value of values) {
+    const hit = positive ? value > 0 : value < 0;
+    current = hit ? current + 1 : 0;
+    best = Math.max(best, current);
+  }
+  return best;
+}
+function groupBy(trades, fn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const key = fn(trade);
+    const group = map.get(key) ?? { key, pnl: 0, count: 0 };
+    group.pnl += trade.netPnl;
+    group.count += 1;
+    map.set(key, group);
+  }
+  return [...map.values()].sort((a, b) => b.pnl - a.pnl);
+}
+function sessionOf(dateIso) {
+  const hour = new Date(dateIso).getUTCHours();
+  if (hour >= 12 && hour < 17) return "london";
+  if (hour >= 17 && hour < 22) return "new-york";
+  if (hour >= 22 || hour < 3) return "asian";
+  return "off-session";
+}
+function calculateStats(trades) {
+  const pnlValues = trades.map((t) => t.netPnl);
+  const wins = trades.filter((t) => t.netPnl > 0);
+  const losses = trades.filter((t) => t.netPnl < 0);
+  const grossProfit = wins.reduce((sum, t) => sum + t.netPnl, 0);
+  const grossLoss = Math.abs(losses.reduce((sum, t) => sum + t.netPnl, 0));
+  const cumulative = [];
+  let running = 0;
+  let peak = 0;
+  let maxDrawdown = 0;
+  for (const trade of trades) {
+    running += trade.netPnl;
+    peak = Math.max(peak, running);
+    maxDrawdown = Math.max(maxDrawdown, peak - running);
+    cumulative.push(running);
+  }
+  return {
+    totalTrades: trades.length,
+    winRate: trades.length ? wins.length / trades.length : 0,
+    netPnL: pnlValues.reduce((sum, value) => sum + value, 0),
+    averageWin: mean(wins.map((t) => t.netPnl)),
+    averageLoss: mean(losses.map((t) => t.netPnl)),
+    profitFactor: grossLoss === 0 ? void 0 : grossProfit / grossLoss,
+    bestTrade: trades.slice().sort((a, b) => b.netPnl - a.netPnl)[0],
+    worstTrade: trades.slice().sort((a, b) => a.netPnl - b.netPnl)[0],
+    maxLosingStreak: streak(pnlValues, false),
+    maxWinningStreak: streak(pnlValues, true),
+    mostTradedSymbol: groupBy(trades, (t) => t.symbol)[0],
+    bestSymbol: groupBy(trades, (t) => t.symbol).sort((a, b) => b.pnl - a.pnl)[0],
+    worstSymbol: groupBy(trades, (t) => t.symbol).sort((a, b) => a.pnl - b.pnl)[0],
+    bestDay: groupBy(trades, (t) => t.openedAt.slice(0, 10))[0],
+    worstDay: groupBy(trades, (t) => t.openedAt.slice(0, 10)).sort((a, b) => a.pnl - b.pnl)[0],
+    bestSession: groupBy(trades, (t) => sessionOf(t.openedAt))[0],
+    worstSession: groupBy(trades, (t) => sessionOf(t.openedAt)).sort((a, b) => a.pnl - b.pnl)[0],
+    drawdownEstimate: maxDrawdown,
+    cumulative
+  };
+}
+function analyzeBySymbol(trades) {
+  return groupBy(trades, (t) => t.symbol);
+}
+function analyzeByDay(trades) {
+  return groupBy(trades, (t) => t.openedAt.slice(0, 10));
+}
+function analyzeBySession(trades) {
+  return groupBy(trades, (t) => sessionOf(t.openedAt));
+}
+function getSession(dateIso) {
+  return sessionOf(dateIso);
+}
+
+// src/lib/mistake-detector.ts
+function detectMistakes(trades) {
+  const stats = calculateStats(trades);
+  const daily = analyzeByDay(trades);
+  const bySymbol = analyzeBySymbol(trades);
+  const bySession = analyzeBySession(trades);
+  const losses = trades.filter((t) => t.netPnl < 0);
+  const averageLot = trades.reduce((sum, trade) => sum + (trade.lotSize ?? 0), 0) / Math.max(trades.length, 1);
+  const overtrading = daily.some((day) => day.count > Math.max(5, Math.ceil(trades.length / 10)));
+  const increasingSizeAfterLoss = trades.some((trade, index) => {
+    const prev = trades[index - 1];
+    return Boolean(prev && prev.netPnl < 0 && (trade.lotSize ?? 0) > (prev.lotSize ?? 0));
+  });
+  const badSessionTrading = bySession.some((session) => session.key !== "off-session" && session.pnl < 0);
+  const repeatedLosingSymbol = bySymbol.some((symbol) => symbol.count >= 2 && symbol.pnl < 0);
+  const losersLonger = trades.some(
+    (trade) => trade.netPnl < 0 && trade.durationMinutes != null && trade.durationMinutes > 2 * (stats.bestTrade?.durationMinutes ?? trade.durationMinutes)
+  );
+  const tooManyTradesPerDay = daily.some((day) => day.count >= 6);
+  const outlierLoss = losses.some((trade) => trade.netPnl <= (stats.averageLoss ?? 0) * 2);
+  const inconsistentSizing = trades.filter((t) => t.lotSize != null).some((trade) => Math.abs((trade.lotSize ?? 0) - averageLot) > averageLot * 0.5);
+  const revengeTrading = trades.some((trade, index) => {
+    const prev = trades[index - 1];
+    return Boolean(prev && prev.netPnl < 0 && trade.openedAt > prev.openedAt && getSession(prev.openedAt) === getSession(trade.openedAt));
+  });
+  return {
+    overtrading,
+    increasingSizeAfterLoss,
+    badSessionTrading,
+    repeatedLosingSymbol,
+    losersLonger,
+    tooManyTradesPerDay,
+    outlierLoss,
+    inconsistentSizing,
+    revengeTrading
+  };
+}
+
+// src/lib/risk-engine.ts
+function buildRiskReport(trades) {
+  const stats = calculateStats(trades);
+  const bySymbol = analyzeBySymbol(trades).sort((a, b) => a.pnl - b.pnl);
+  const byDay = analyzeByDay(trades).sort((a, b) => a.pnl - b.pnl);
+  const bySession = analyzeBySession(trades).sort((a, b) => a.pnl - b.pnl);
+  const biggestLoss = stats.worstTrade?.netPnl;
+  const averageLoss = stats.averageLoss;
+  const lossStreaks = stats.maxLosingStreak;
+  const overtradingSignals = trades.length > 0 && stats.totalTrades / Math.max(1, new Set(trades.map((t) => t.openedAt.slice(0, 10))).size) > 4;
+  const revengeTradingSignals = trades.some((trade, index) => Boolean(trades[index - 1] && trades[index - 1].netPnl < 0 && trade.netPnl < 0));
+  return {
+    biggestLoss,
+    averageLoss,
+    lossStreaks,
+    drawdownEstimate: stats.drawdownEstimate,
+    worstSymbols: bySymbol.slice(0, 3),
+    worstDays: byDay.slice(0, 3),
+    worstSessions: bySession.slice(0, 3),
+    overtradingSignals,
+    revengeTradingSignals
+  };
+}
+
+// src/lib/report-formatters.ts
+var money = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+function fmt(value) {
+  if (value == null || Number.isNaN(value)) return "n/a";
+  return money.format(value);
+}
+function formatStats(trades) {
+  const s = calculateStats(trades);
+  return [
+    `Total trades: ${s.totalTrades}`,
+    `Win rate: ${(s.winRate * 100).toFixed(1)}%`,
+    `Net PnL: ${fmt(s.netPnL)}`,
+    `Average win: ${fmt(s.averageWin)}`,
+    `Average loss: ${fmt(s.averageLoss)}`,
+    `Profit factor: ${s.profitFactor?.toFixed(2) ?? "n/a"}`,
+    `Best trade: ${fmt(s.bestTrade?.netPnl)}`,
+    `Worst trade: ${fmt(s.worstTrade?.netPnl)}`,
+    `Max losing streak: ${s.maxLosingStreak}`,
+    `Max winning streak: ${s.maxWinningStreak}`,
+    `Most traded symbol: ${s.mostTradedSymbol?.key ?? "n/a"}`,
+    `Best symbol: ${s.bestSymbol?.key ?? "n/a"}`,
+    `Worst symbol: ${s.worstSymbol?.key ?? "n/a"}`,
+    `Best day: ${s.bestDay?.key ?? "n/a"}`,
+    `Worst day: ${s.worstDay?.key ?? "n/a"}`,
+    `Best session: ${s.bestSession?.key ?? "n/a"}`,
+    `Worst session: ${s.worstSession?.key ?? "n/a"}`
+  ].join("\n");
+}
+function formatRisk(trades) {
+  const r = buildRiskReport(trades);
+  return [
+    `Biggest loss: ${fmt(r.biggestLoss)}`,
+    `Average loss: ${fmt(r.averageLoss)}`,
+    `Loss streaks: ${r.lossStreaks}`,
+    `Drawdown estimate: ${fmt(r.drawdownEstimate)}`,
+    `Worst symbols: ${r.worstSymbols.map((x) => `${x.key} (${fmt(x.pnl)})`).join(", ") || "n/a"}`,
+    `Worst days: ${r.worstDays.map((x) => `${x.key} (${fmt(x.pnl)})`).join(", ") || "n/a"}`,
+    `Worst sessions: ${r.worstSessions.map((x) => `${x.key} (${fmt(x.pnl)})`).join(", ") || "n/a"}`,
+    `Overtrading signals: ${r.overtradingSignals ? "yes" : "no"}`,
+    `Revenge trading signals: ${r.revengeTradingSignals ? "yes" : "no"}`
+  ].join("\n");
+}
+function formatMistakes(trades) {
+  const m = detectMistakes(trades);
+  return [
+    `Overtrading: ${m.overtrading ? "yes" : "no"}`,
+    `Increasing size after loss: ${m.increasingSizeAfterLoss ? "yes" : "no"}`,
+    `Trading during bad session: ${m.badSessionTrading ? "yes" : "no"}`,
+    `Repeating same losing symbol: ${m.repeatedLosingSymbol ? "yes" : "no"}`,
+    `Holding losers longer than winners: ${m.losersLonger ? "yes" : "no"}`,
+    `Too many trades per day: ${m.tooManyTradesPerDay ? "yes" : "no"}`,
+    `Large outlier loss: ${m.outlierLoss ? "yes" : "no"}`,
+    `Inconsistent lot sizing: ${m.inconsistentSizing ? "yes" : "no"}`
+  ].join("\n");
+}
+function formatWeeklyReview(trades) {
+  const s = calculateStats(trades);
+  const m = detectMistakes(trades);
+  return [
+    `What went well: ${s.bestSymbol?.key ?? "n/a"} and ${s.bestSession?.key ?? "n/a"} were the strongest areas.`,
+    `What went wrong: ${s.worstSymbol?.key ?? "n/a"} and ${s.worstSession?.key ?? "n/a"} were the weakest areas.`,
+    `Biggest mistake: ${m.overtrading ? "Overtrading showed up." : "No dominant mistake was detected."}`,
+    `Biggest risk leak: ${m.increasingSizeAfterLoss ? "Sizing increased after losses." : "No clear size escalation leak found."}`,
+    `Best symbol/session: ${s.bestSymbol?.key ?? "n/a"} / ${s.bestSession?.key ?? "n/a"}`,
+    `Worst symbol/session: ${s.worstSymbol?.key ?? "n/a"} / ${s.worstSession?.key ?? "n/a"}`,
+    `Rule for next week: Keep trade count controlled and stop after the first rule break.`
+  ].join("\n");
+}
+function formatTomorrowPlan(trades) {
+  const s = calculateStats(trades);
+  const badSymbols = [s.worstSymbol?.key, s.bestSymbol && s.bestSymbol.pnl < 0 ? s.bestSymbol.key : void 0].filter(Boolean);
+  return [
+    `Max trades suggestion: ${Math.max(1, Math.min(5, Math.ceil(trades.length / 3)))}`,
+    `Risk cap suggestion: ${trades.length ? "Keep per-trade risk at or below 1% until consistency improves." : "Import trades first."}`,
+    `Symbols to avoid: ${badSymbols.length ? badSymbols.join(", ") : "n/a"}`,
+    `Session warnings: avoid sessions that have been net negative in your history.`,
+    `One discipline rule: do not add size after a loss.`,
+    `Not financial advice.`
+  ].join("\n");
+}
+function formatRulesStatus(trades, rules) {
+  const lines = [
+    `Ruleset: ${rules.name}`,
+    `Max daily loss percent: ${rules.maxDailyLossPercent ?? "n/a"}`,
+    `Max total drawdown percent: ${rules.maxTotalDrawdownPercent ?? "n/a"}`,
+    `Max trades per day: ${rules.maxTradesPerDay ?? "n/a"}`,
+    `Max risk per trade percent: ${rules.maxRiskPerTradePercent ?? "n/a"}`
+  ];
+  if (!trades.length) {
+    lines.push("No trades imported yet, so limits cannot be evaluated.");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/stats.ts
+async function runStats() {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  return formatStats(trades);
+}
+
+// src/commands/risk.ts
+async function runRisk() {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  return formatRisk(trades);
+}
+
+// src/commands/mistakes.ts
+async function runMistakes() {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  return formatMistakes(trades);
+}
+
+// src/commands/review.ts
+async function runReview(_range) {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  return `${formatWeeklyReview(trades)}
+Not financial advice.`;
+}
+
+// src/commands/plan.ts
+async function runPlan(_range) {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  return formatTomorrowPlan(trades);
+}
+
+// src/lib/rules-engine.ts
+function defaultFtmoRules() {
+  return {
+    name: "ftmo",
+    maxDailyLossPercent: 5,
+    maxTotalDrawdownPercent: 10,
+    maxTradesPerDay: 5,
+    maxRiskPerTradePercent: 1
+  };
+}
+
+// src/commands/rules.ts
+async function runRulesSet(name) {
+  const { rulesFile } = await ensureStorage();
+  const rules = name.toLowerCase() === "ftmo" ? defaultFtmoRules() : { name };
+  await writeJsonFile(rulesFile, rules);
+  return `Saved ruleset ${rules.name}.`;
+}
+async function runRulesStatus() {
+  const { rulesFile, tradesFile } = await ensureStorage();
+  const rules = await readJsonFile(rulesFile, defaultFtmoRules());
+  const trades = await readJsonFile(tradesFile, []);
+  return formatRulesStatus(trades, rules);
+}
+
+// src/commands/init.ts
+async function runInit() {
+  const paths = await ensureStorage();
+  return [`Initialized Tradia storage at ${paths.baseDir}.`, "No secrets stored.", "No network calls required."].join("\n");
+}
+
+// src/tui/app.ts
+async function runInteractiveHome() {
+  const choice = await promptMenu("Tradia\n\nLocal-first trading intelligence for prop firm traders.\n", [
+    "Import trades",
+    "Account stats",
+    "Risk report",
+    "Mistake report",
+    "Weekly review",
+    "Tomorrow plan",
+    "Prop firm rules",
+    "Settings",
+    "Exit"
+  ]);
+  const actions = [
+    async () => console.log(await runImport("./trades.csv")),
+    async () => console.log(await runStats()),
+    async () => console.log(await runRisk()),
+    async () => console.log(await runMistakes()),
+    async () => console.log(await runReview("week")),
+    async () => console.log(await runPlan("tomorrow")),
+    async () => console.log(await runRulesStatus()),
+    async () => console.log(await runInit()),
+    async () => process.exit(0)
+  ];
+  await actions[choice]();
+}
+
+// src/commands/trades.ts
+async function runTradesList() {
+  const { tradesFile } = await ensureStorage();
+  const trades = await readJsonFile(tradesFile, []);
+  if (!trades.length) return "No trades imported yet.";
+  return trades.map((trade) => `${trade.openedAt.slice(0, 10)} ${trade.symbol} ${trade.side} pnl=${trade.netPnl.toFixed(2)} id=${trade.id}`).join("\n");
+}
+
+// src/commands/doctor.ts
+async function runDoctor() {
+  const paths = await ensureStorage();
+  const nodeVersion = process.version;
+  const checks = [
+    `Node version: ${nodeVersion}`,
+    `Config dir: ${paths.baseDir}`,
+    `Trades file exists: ${await fileExists(paths.tradesFile) ? "yes" : "no"}`,
+    `Rules file exists: ${await fileExists(paths.rulesFile) ? "yes" : "no"}`,
+    `Package version: ${PACKAGE_VERSION}`,
+    "No network/API required: yes",
+    "No secrets printed: yes"
+  ];
+  return checks.join("\n");
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  program.command("init").description("Create local Tradia storage").action(async () => console.log(await runInit()));
+  program.command("import <csv>").description("Import a CSV trade history export").action(async (csv) => console.log(await runImport(csv)));
+  program.command("trades").description("Trade commands").command("list").description("List imported trades").action(async () => console.log(await runTradesList()));
+  program.command("stats").description("Show trade stats").action(async () => console.log(await runStats()));
+  program.command("mistakes").description("Show mistake report").action(async () => console.log(await runMistakes()));
+  program.command("risk").description("Show risk report").action(async () => console.log(await runRisk()));
+  program.command("review <range>").description("Generate a deterministic review").action(async (range) => console.log(await runReview(range)));
+  program.command("plan <range>").description("Generate a deterministic plan").action(async (range) => console.log(await runPlan(range)));
+  const rules = program.command("rules").description("Prop firm rules");
+  rules.command("set <name>").description("Set prop firm rules").action(async (name) => console.log(await runRulesSet(name)));
+  rules.command("status").description("Show rules status").action(async () => console.log(await runRulesStatus()));
+  program.command("doctor").description("Run environment checks").action(async () => console.log(await runDoctor()));
+}
+
+// src/cli.ts
+async function main() {
+  const program = new Command();
+  program.name("tradia").description("Local-first trading intelligence for prop firm traders.").version(PACKAGE_VERSION);
+  registerCommands(program);
+  program.action(async () => {
+    await runInteractiveHome();
+  });
+  await program.parseAsync(process.argv);
+}
+
+// src/index.ts
+void main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@talocode/tradia",
+  "version": "0.1.0",
+  "description": "Local-first terminal trading intelligence for prop firm traders.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Talocode",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/talocode/tradia.git",
+    "directory": "packages/tradia-tui"
+  },
+  "homepage": "https://github.com/talocode/tradia#tradia-tui",
+  "bugs": {
+    "url": "https://github.com/talocode/tradia/issues"
+  },
+  "keywords": ["trading", "terminal", "tui", "journal", "risk", "prop-firm"],
+  "bin": {
+    "tradia": "dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup && chmod +x dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}