@t2000/cli 0.15.3 → 0.16.0

package/dist/index.js

@@ -1822,7 +1822,7 @@ function registerMcp(program2) {
   mcp.command("start", { isDefault: true }).description("Start MCP server (stdio transport)").option("--key <path>", "Key file path").action(async (opts) => {
     let mod;
     try {
-      mod = await import("./dist-TXXQC3NH.js");
+      mod = await import("./dist-VP2F4RTR.js");
     } catch {
       console.error(
         "MCP server not installed. Run:\n  npm install -g @t2000/mcp"
@@ -2093,11 +2093,369 @@ function registerInvest(program2) {
       handleError(error);
     }
   });
+  const strategyCmd = investCmd.command("strategy").description("Manage investment strategies");
+  strategyCmd.command("list").description("List available strategies").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const all = agent.strategies.getAll();
+      if (isJsonMode()) {
+        printJson(all);
+        return;
+      }
+      printBlank();
+      printHeader("Investment Strategies");
+      printSeparator();
+      for (const [key, def] of Object.entries(all)) {
+        const allocs = Object.entries(def.allocations).map(([a, p]) => `${a} ${p}%`).join(", ");
+        const tag = def.custom ? pc13.dim(" (custom)") : "";
+        printKeyValue(key, `${allocs}${tag}`);
+        printLine(`    ${pc13.dim(def.description)}`);
+      }
+      printSeparator();
+      const hasPositions = Object.keys(all).some((k) => agent.portfolio.hasStrategyPositions(k));
+      if (!hasPositions) {
+        printInfo("Buy into a strategy: t2000 invest strategy buy bluechip 100");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("buy <name> <amount>").description("Buy into a strategy").option("--key <path>", "Key file path").option("--dry-run", "Preview allocation without executing").action(async (name, amount, opts) => {
+    try {
+      const parsed = parseFloat(amount);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.error(pc13.red("  \u2717 Amount must be greater than $0"));
+        process.exitCode = 1;
+        return;
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investStrategy({ strategy: name.toLowerCase(), usdAmount: parsed, dryRun: opts.dryRun });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (opts.dryRun) {
+        printHeader(`Strategy: ${name} \u2014 Dry Run (${formatUsd15(parsed)})`);
+        printSeparator();
+        for (const buy of result.buys) {
+          printKeyValue(buy.asset, `${formatUsd15(buy.usdAmount)} \u2192 ~${formatAssetAmount(buy.amount, buy.asset)} ${buy.asset} @ ${formatUsd15(buy.price)}`);
+        }
+        printSeparator();
+        printInfo("Run without --dry-run to execute");
+      } else {
+        printSuccess(`Invested ${formatUsd15(parsed)} in ${name} strategy`);
+        printSeparator();
+        for (const buy of result.buys) {
+          printKeyValue(buy.asset, `${formatAssetAmount(buy.amount, buy.asset)} @ ${formatUsd15(buy.price)}`);
+          printLine(`    ${pc13.dim(`Tx: ${explorerUrl(buy.tx)}`)}`);
+        }
+        printSeparator();
+        printKeyValue("Total invested", formatUsd15(result.totalInvested));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("sell <name>").description("Sell all positions in a strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.sellStrategy({ strategy: name.toLowerCase() });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Sold all ${name} strategy positions`);
+      printSeparator();
+      for (const sell of result.sells) {
+        const pnlColor = sell.realizedPnL >= 0 ? pc13.green : pc13.red;
+        const pnlSign = sell.realizedPnL >= 0 ? "+" : "";
+        printKeyValue(sell.asset, `${formatAssetAmount(sell.amount, sell.asset)} \u2192 ${formatUsd15(sell.usdValue)}  ${pnlColor(`${pnlSign}${formatUsd15(sell.realizedPnL)}`)}`);
+      }
+      printSeparator();
+      printKeyValue("Total proceeds", formatUsd15(result.totalProceeds));
+      const rpnlColor = result.realizedPnL >= 0 ? pc13.green : pc13.red;
+      const rpnlSign = result.realizedPnL >= 0 ? "+" : "";
+      printKeyValue("Realized P&L", rpnlColor(`${rpnlSign}${formatUsd15(result.realizedPnL)}`));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("status <name>").description("Show current status and weights of a strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = await agent.getStrategyStatus(name.toLowerCase());
+      if (isJsonMode()) {
+        printJson(status);
+        return;
+      }
+      printBlank();
+      printHeader(`Strategy: ${status.definition.name}`);
+      printSeparator();
+      if (status.positions.length === 0) {
+        printInfo("No positions yet. Buy in with: t2000 invest strategy buy " + name + " 100");
+      } else {
+        for (const pos of status.positions) {
+          const target = status.definition.allocations[pos.asset] ?? 0;
+          const actual = status.currentWeights[pos.asset] ?? 0;
+          const drift = actual - target;
+          const driftColor = Math.abs(drift) > 3 ? pc13.yellow : pc13.dim;
+          const pnlColor = pos.unrealizedPnL >= 0 ? pc13.green : pc13.red;
+          const pnlSign = pos.unrealizedPnL >= 0 ? "+" : "";
+          printKeyValue(
+            pos.asset,
+            `${formatAssetAmount(pos.totalAmount, pos.asset)}  ${formatUsd15(pos.currentValue)}  ${pnlColor(`${pnlSign}${formatUsd15(pos.unrealizedPnL)}`)}  ${driftColor(`${actual.toFixed(0)}% / ${target}% target`)}`
+          );
+        }
+        printSeparator();
+        printKeyValue("Total value", formatUsd15(status.totalValue));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("rebalance <name>").description("Rebalance a strategy to target weights").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.rebalanceStrategy({ strategy: name.toLowerCase() });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.trades.length === 0) {
+        printInfo(`Strategy '${name}' is already balanced (within 3% threshold)`);
+      } else {
+        printSuccess(`Rebalanced ${name} strategy`);
+        printSeparator();
+        for (const t of result.trades) {
+          const action = t.action === "buy" ? pc13.green("BUY") : pc13.red("SELL");
+          printKeyValue(t.asset, `${action} ${formatUsd15(t.usdAmount)} (${formatAssetAmount(t.amount, t.asset)})`);
+        }
+        printSeparator();
+        printInfo("Weights: " + Object.entries(result.afterWeights).map(([a, w]) => `${a} ${w.toFixed(0)}%`).join(", "));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("create <name>").description("Create a custom strategy").requiredOption("--alloc <pairs...>", "Allocations e.g. SUI:60 BTC:20 ETH:20").option("--description <desc>", "Strategy description").action(async (name, opts) => {
+    try {
+      const allocations = {};
+      for (const pair of opts.alloc) {
+        const [asset, pctStr] = pair.split(":");
+        if (!asset || !pctStr) {
+          console.error(pc13.red(`  \u2717 Invalid allocation: '${pair}'. Use ASSET:PCT format (e.g. SUI:60)`));
+          process.exitCode = 1;
+          return;
+        }
+        allocations[asset.toUpperCase()] = parseFloat(pctStr);
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin });
+      const definition = agent.strategies.create({ name, allocations, description: opts.description });
+      if (isJsonMode()) {
+        printJson(definition);
+        return;
+      }
+      printBlank();
+      printSuccess(`Created strategy '${name}'`);
+      const allocs = Object.entries(definition.allocations).map(([a, p]) => `${a} ${p}%`).join(", ");
+      printKeyValue("Allocations", allocs);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("delete <name>").description("Delete a custom strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      if (agent.portfolio.hasStrategyPositions(name.toLowerCase())) {
+        console.error(pc13.red(`  \u2717 Strategy '${name}' has open positions. Sell first: t2000 invest strategy sell ${name}`));
+        process.exitCode = 1;
+        return;
+      }
+      agent.strategies.delete(name.toLowerCase());
+      if (isJsonMode()) {
+        printJson({ deleted: name });
+        return;
+      }
+      printBlank();
+      printSuccess(`Deleted strategy '${name}'`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  const autoCmd = investCmd.command("auto").description("Dollar-cost averaging (DCA) schedules");
+  autoCmd.command("setup <amount> <frequency> [target]").description("Create a DCA schedule (target = strategy name or asset)").option("--key <path>", "Key file path").option("--day <num>", "Day of week (1-7) or month (1-28)").action(async (amount, frequency, target, opts) => {
+    try {
+      const parsed = parseFloat(amount);
+      if (isNaN(parsed) || parsed < 1) {
+        console.error(pc13.red("  \u2717 Amount must be at least $1"));
+        process.exitCode = 1;
+        return;
+      }
+      if (!["daily", "weekly", "monthly"].includes(frequency)) {
+        console.error(pc13.red("  \u2717 Frequency must be daily, weekly, or monthly"));
+        process.exitCode = 1;
+        return;
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const allStrategies = agent.strategies.getAll();
+      const isStrategy = target ? target.toLowerCase() in allStrategies : false;
+      const isAsset = target ? ["SUI", "BTC", "ETH"].includes(target.toUpperCase()) : false;
+      if (target && !isStrategy && !isAsset) {
+        console.error(pc13.red(`  \u2717 '${target}' is not a valid strategy or asset`));
+        process.exitCode = 1;
+        return;
+      }
+      const dayNum = opts.day ? parseInt(opts.day, 10) : void 0;
+      const schedule = agent.setupAutoInvest({
+        amount: parsed,
+        frequency,
+        strategy: isStrategy ? target.toLowerCase() : void 0,
+        asset: isAsset ? target.toUpperCase() : void 0,
+        dayOfWeek: frequency === "weekly" ? dayNum : void 0,
+        dayOfMonth: frequency === "monthly" ? dayNum : void 0
+      });
+      if (isJsonMode()) {
+        printJson(schedule);
+        return;
+      }
+      printBlank();
+      const targetLabel = schedule.strategy ?? schedule.asset ?? "unknown";
+      printSuccess(`Auto-invest created: ${formatUsd15(schedule.amount)} ${schedule.frequency} \u2192 ${targetLabel}`);
+      printKeyValue("Schedule ID", schedule.id);
+      printKeyValue("Next run", new Date(schedule.nextRun).toLocaleDateString());
+      printInfo("Run manually: t2000 invest auto run");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("status").description("Show all DCA schedules").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = agent.getAutoInvestStatus();
+      if (isJsonMode()) {
+        printJson(status);
+        return;
+      }
+      printBlank();
+      if (status.schedules.length === 0) {
+        printInfo("No auto-invest schedules. Set one up: t2000 invest auto setup 50 weekly bluechip");
+        printBlank();
+        return;
+      }
+      printHeader("Auto-Invest Schedules");
+      printSeparator();
+      for (const s of status.schedules) {
+        const target = s.strategy ?? s.asset ?? "?";
+        const statusTag = s.enabled ? pc13.green("active") : pc13.dim("paused");
+        printKeyValue(s.id, `${formatUsd15(s.amount)} ${s.frequency} \u2192 ${target}  ${statusTag}`);
+        printLine(`    ${pc13.dim(`Next: ${new Date(s.nextRun).toLocaleDateString()} \xB7 Runs: ${s.runCount} \xB7 Total: ${formatUsd15(s.totalInvested)}`)}`);
+      }
+      printSeparator();
+      if (status.pendingRuns.length > 0) {
+        printInfo(`${status.pendingRuns.length} pending run(s). Execute: t2000 invest auto run`);
+      } else {
+        printInfo("All schedules up to date");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("run").description("Execute pending DCA purchases").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = agent.getAutoInvestStatus();
+      if (status.pendingRuns.length === 0) {
+        if (isJsonMode()) {
+          printJson({ executed: [], skipped: [] });
+          return;
+        }
+        printBlank();
+        printInfo("No pending auto-invest runs. All schedules are up to date.");
+        printBlank();
+        return;
+      }
+      const result = await agent.runAutoInvest();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.executed.length > 0) {
+        printSuccess(`Executed ${result.executed.length} auto-invest run(s)`);
+        for (const exec of result.executed) {
+          const target = exec.strategy ?? exec.asset ?? "?";
+          printKeyValue(target, formatUsd15(exec.amount));
+        }
+      }
+      if (result.skipped.length > 0) {
+        for (const skip of result.skipped) {
+          printLine(`  ${pc13.yellow("\u26A0")} Skipped ${skip.scheduleId}: ${skip.reason}`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("stop <id>").description("Stop an auto-invest schedule").option("--key <path>", "Key file path").action(async (id, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      agent.stopAutoInvest(id);
+      if (isJsonMode()) {
+        printJson({ stopped: id });
+        return;
+      }
+      printBlank();
+      printSuccess(`Stopped auto-invest schedule ${id}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
 }
 
 // src/commands/portfolio.ts
 import pc14 from "picocolors";
 import { T2000 as T200025, formatUsd as formatUsd16, formatAssetAmount as formatAssetAmount2 } from "@t2000/sdk";
+function printPositionLine(pos) {
+  if (pos.currentPrice === 0 && pos.totalAmount > 0) {
+    printKeyValue(
+      pos.asset,
+      `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${pc14.yellow("unavailable")}`
+    );
+  } else {
+    const pnlColor = pos.unrealizedPnL >= 0 ? pc14.green : pc14.red;
+    const pnlSign = pos.unrealizedPnL >= 0 ? "+" : "";
+    const yieldSuffix = pos.earning && pos.earningApy ? `    ${pc14.cyan(`${pos.earningApy.toFixed(1)}% APY (${pos.earningProtocol})`)}` : "";
+    printKeyValue(
+      pos.asset,
+      `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${formatUsd16(pos.currentPrice)}    ${pnlColor(`${pnlSign}${formatUsd16(pos.unrealizedPnL)} (${pnlSign}${pos.unrealizedPnLPct.toFixed(1)}%)`)}${yieldSuffix}`
+    );
+  }
+}
 function registerPortfolio(program2) {
   program2.command("portfolio").description("Show investment portfolio").option("--key <path>", "Key file path").action(async (opts) => {
     try {
@@ -2109,27 +2467,43 @@ function registerPortfolio(program2) {
         return;
       }
       printBlank();
-      if (portfolio.positions.length === 0) {
+      const hasDirectPositions = portfolio.positions.length > 0;
+      const hasStrategyPositions = portfolio.strategyPositions && Object.keys(portfolio.strategyPositions).length > 0;
+      if (!hasDirectPositions && !hasStrategyPositions) {
         printInfo("No investments yet. Try: t2000 invest buy 100 SUI");
         printBlank();
         return;
       }
       printHeader("Investment Portfolio");
-      printSeparator();
-      for (const pos of portfolio.positions) {
-        if (pos.currentPrice === 0 && pos.totalAmount > 0) {
-          printKeyValue(
-            pos.asset,
-            `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${pc14.yellow("unavailable")}`
-          );
-        } else {
-          const pnlColor = pos.unrealizedPnL >= 0 ? pc14.green : pc14.red;
-          const pnlSign = pos.unrealizedPnL >= 0 ? "+" : "";
-          const yieldSuffix = pos.earning && pos.earningApy ? `    ${pc14.cyan(`${pos.earningApy.toFixed(1)}% APY (${pos.earningProtocol})`)}` : "";
-          printKeyValue(
-            pos.asset,
-            `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${formatUsd16(pos.currentPrice)}    ${pnlColor(`${pnlSign}${formatUsd16(pos.unrealizedPnL)} (${pnlSign}${pos.unrealizedPnLPct.toFixed(1)}%)`)}${yieldSuffix}`
-          );
+      if (hasStrategyPositions) {
+        for (const [key, positions] of Object.entries(portfolio.strategyPositions)) {
+          let stratLabel = key;
+          try {
+            const def = agent.strategies.get(key);
+            stratLabel = def.name;
+          } catch {
+          }
+          printLine(`  ${pc14.bold(pc14.cyan(`\u25B8 ${stratLabel}`))}`);
+          printSeparator();
+          for (const pos of positions) {
+            printPositionLine(pos);
+          }
+          const stratValue = positions.reduce((s, p) => s + p.currentValue, 0);
+          printLine(`  ${pc14.dim(`Subtotal: ${formatUsd16(stratValue)}`)}`);
+          printBlank();
+        }
+      }
+      if (hasDirectPositions) {
+        if (hasStrategyPositions) {
+          printLine(`  ${pc14.bold(pc14.cyan("\u25B8 Direct"))}`);
+        }
+        printSeparator();
+        for (const pos of portfolio.positions) {
+          printPositionLine(pos);
+        }
+        if (hasStrategyPositions) {
+          const directValue = portfolio.positions.reduce((s, p) => s + p.currentValue, 0);
+          printLine(`  ${pc14.dim(`Subtotal: ${formatUsd16(directValue)}`)}`);
         }
       }
       printSeparator();