@akta/dao-cli 0.1.0

package/src/index.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import type { AkitaNetwork } from "@akta/sdk";
+import { createDAO } from "./sdk";
+import { infoCommand } from "./commands/info";
+import { stateCommand } from "./commands/state";
+import { listProposals, getProposal } from "./commands/proposals";
+import {
+  walletInfo,
+  walletPlugins,
+  walletNamedPlugins,
+  walletEscrows,
+  walletAllowances,
+  walletExecutions,
+  walletBalance,
+} from "./commands/wallet";
+import { startTUI } from "./tui/app";
+
+const program = new Command();
+
+program
+  .name("akita-dao")
+  .description("Read-only CLI for querying Akita DAO state on Algorand")
+  .version("0.1.0")
+  .option("-n, --network <network>", "Network to connect to", "mainnet")
+  .option("-j, --json", "Output as JSON", false);
+
+function getOpts(): { network: AkitaNetwork; json: boolean } {
+  const opts = program.opts();
+  const network = opts.network as AkitaNetwork;
+  if (!["mainnet", "testnet", "localnet"].includes(network)) {
+    console.error(`Invalid network: ${network}. Use mainnet, testnet, or localnet.`);
+    process.exit(1);
+  }
+  return { network, json: opts.json };
+}
+
+// tui
+program
+  .command("tui")
+  .description("Launch interactive full-screen TUI")
+  .action(async () => {
+    const { network } = getOpts();
+    await startTUI(network);
+  });
+
+// info
+program
+  .command("info")
+  .description("Quick DAO dashboard (app IDs, assets, version)")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await infoCommand(dao, network, json);
+  });
+
+// state
+program
+  .command("state")
+  .description("Full decoded global state")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await stateCommand(dao, network, json);
+  });
+
+// proposals
+const proposals = program
+  .command("proposals")
+  .description("Proposal commands");
+
+proposals
+  .command("list")
+  .description("List proposals")
+  .option("-s, --status <status>", "Filter by status: all, active, past", "all")
+  .option("-l, --limit <limit>", "Max proposals to show", "20")
+  .action(async (opts) => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await listProposals(dao, json, opts.status, parseInt(opts.limit, 10));
+  });
+
+proposals
+  .command("get <id>")
+  .description("Get detailed proposal view")
+  .action(async (id: string) => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await getProposal(dao, BigInt(id), json);
+  });
+
+// wallet
+const walletCmd = program
+  .command("wallet")
+  .description("Wallet commands");
+
+walletCmd
+  .command("info")
+  .description("Wallet global state")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletInfo(dao, network, json);
+  });
+
+walletCmd
+  .command("plugins")
+  .description("All installed plugins")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletPlugins(dao, network, json);
+  });
+
+walletCmd
+  .command("named-plugins")
+  .description("Named plugin aliases")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletNamedPlugins(dao, json);
+  });
+
+walletCmd
+  .command("escrows")
+  .description("All escrows")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletEscrows(dao, json);
+  });
+
+walletCmd
+  .command("allowances")
+  .description("All spending allowances")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletAllowances(dao, json);
+  });
+
+walletCmd
+  .command("executions")
+  .description("All execution keys")
+  .action(async () => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletExecutions(dao, json);
+  });
+
+walletCmd
+  .command("balance [assets...]")
+  .description("Check balances (default: ALGO, AKTA, BONES)")
+  .option("-e, --escrow <name>", "Check escrow balance instead of main wallet")
+  .action(async (assets: string[], opts: { escrow?: string }) => {
+    const { network, json } = getOpts();
+    const dao = createDAO(network);
+    await walletBalance(dao, network, json, assets, opts.escrow);
+  });
+
+// Hoist global flags (e.g. -n testnet) before the subcommand so Commander parses them
+const GLOBAL_VALUE_FLAGS = new Set(["-n", "--network"]);
+const GLOBAL_BOOL_FLAGS = new Set(["-j", "--json"]);
+
+function hoistGlobalFlags(args: string[]): string[] {
+  const flags: string[] = [];
+  const rest: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (GLOBAL_VALUE_FLAGS.has(args[i]) && i + 1 < args.length) {
+      flags.push(args[i], args[i + 1]);
+      i++;
+    } else if (GLOBAL_BOOL_FLAGS.has(args[i])) {
+      flags.push(args[i]);
+    } else {
+      rest.push(args[i]);
+    }
+  }
+  return [...flags, ...rest];
+}
+
+const userArgs = hoistGlobalFlags(process.argv.slice(2));
+const hasCommand = userArgs.some((arg) => !arg.startsWith("-"));
+
+if (!hasCommand && process.stdout.isTTY) {
+  program.parse([...process.argv.slice(0, 2), ...userArgs, "tui"]);
+} else {
+  program.parse([...process.argv.slice(0, 2), ...userArgs]);
+}

package/src/output.ts

@@ -0,0 +1,232 @@
+import theme from "./theme";
+
+// ── Internal helpers ─────────────────────────────────────────────
+
+/** Strip ANSI escape codes for accurate visible-length calculation */
+export function visibleLength(str: string): number {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+
+/** padEnd that accounts for invisible ANSI escape codes */
+export function padEndVisible(str: string, len: number): string {
+  const diff = len - visibleLength(str);
+  return diff > 0 ? str + " ".repeat(diff) : str;
+}
+
+/** Truncate a string that may contain ANSI codes to a visible width */
+export function truncateAnsi(str: string, maxWidth: number): string {
+  let visible = 0;
+  let i = 0;
+  let result = "";
+
+  while (i < str.length && visible < maxWidth) {
+    // Check for ANSI escape sequence
+    if (str[i] === "\x1b" && str[i + 1] === "[") {
+      const end = str.indexOf("m", i);
+      if (end !== -1) {
+        result += str.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+    }
+    result += str[i];
+    visible++;
+    i++;
+  }
+
+  // Reset ANSI at end
+  return result + "\x1b[0m";
+}
+
+/** Terminal width with fallback for piped/non-TTY output */
+function termWidth(): number {
+  return process.stdout.columns || 120;
+}
+
+// ── JSON output (unchanged) ──────────────────────────────────────
+
+export function jsonReplacer(_key: string, value: unknown): unknown {
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("hex");
+  return value;
+}
+
+export function printJson(data: unknown): void {
+  console.log(JSON.stringify(data, jsonReplacer, 2));
+}
+
+// ── Section header ───────────────────────────────────────────────
+
+export function renderHeader(text: string, width?: number): string[] {
+  const w = width ?? termWidth();
+  const prefix = "── ";
+  const suffix = " ";
+  const remaining = w - prefix.length - text.length - suffix.length;
+  const rule = remaining > 0 ? "─".repeat(remaining) : "";
+  return [
+    "",
+    `${theme.label(prefix)}${theme.sectionHeader(text)}${theme.label(suffix + rule)}`,
+  ];
+}
+
+export function header(text: string): void {
+  for (const line of renderHeader(text)) console.log(line);
+}
+
+// ── Key-Value pairs ──────────────────────────────────────────────
+
+export function renderKV(pairs: [string, unknown][]): string[] {
+  if (pairs.length === 0) return [];
+  const maxKeyLen = Math.max(...pairs.map(([k]) => k.length));
+  return pairs.map(([key, value]) => {
+    const paddedKey = key.padEnd(maxKeyLen);
+    return `  ${theme.label(paddedKey)}  ${String(value)}`;
+  });
+}
+
+export function printKV(pairs: [string, unknown][]): void {
+  for (const line of renderKV(pairs)) console.log(line);
+}
+
+// ── Data table (borderless aligned columns) ──────────────────────
+
+export function renderColumns(headers: string[], rows: string[][]): string[] {
+  if (rows.length === 0) return [];
+
+  const colWidths = headers.map((h, i) => {
+    const dataMax = rows.reduce((max, row) => Math.max(max, visibleLength(row[i] ?? "")), 0);
+    return Math.max(h.length, dataMax);
+  });
+
+  const gap = 3;
+  const lines: string[] = [];
+
+  const headerLine = headers
+    .map((h, i) => padEndVisible(theme.label(h.toUpperCase()), colWidths[i]))
+    .join(" ".repeat(gap));
+  lines.push(`  ${headerLine}`);
+
+  for (const row of rows) {
+    const line = row
+      .map((cell, i) => {
+        if (i === row.length - 1) return cell;
+        return padEndVisible(cell, colWidths[i]);
+      })
+      .join(" ".repeat(gap));
+    lines.push(`  ${line}`);
+  }
+
+  return lines;
+}
+
+export function printColumns(headers: string[], rows: string[][]): void {
+  for (const line of renderColumns(headers, rows)) console.log(line);
+}
+
+// ── Multi-column KV (side-by-side fee groups) ────────────────────
+
+export interface KVGroup {
+  title: string;
+  pairs: [string, string][];
+}
+
+export function renderMultiColumnKV(groups: KVGroup[], width?: number): string[] {
+  if (groups.length === 0) return [];
+
+  const w = width ?? termWidth();
+  const groupGap = 4;
+  const indent = 2;
+  const lines: string[] = [];
+
+  let cols: number;
+  if (w >= 120) cols = Math.min(3, groups.length);
+  else if (w >= 80) cols = Math.min(2, groups.length);
+  else cols = 1;
+
+  for (let i = 0; i < groups.length; i += cols) {
+    const chunk = groups.slice(i, i + cols);
+
+    const groupMetas = chunk.map((g) => {
+      const maxKey = Math.max(g.title.length, ...g.pairs.map(([k]) => k.length));
+      const maxVal = Math.max(...g.pairs.map(([, v]) => visibleLength(v)), 0);
+      return { group: g, keyWidth: maxKey, valWidth: maxVal, totalWidth: maxKey + 2 + maxVal };
+    });
+
+    const titleLine = groupMetas
+      .map((m, idx) => {
+        const title = theme.label(m.group.title.toUpperCase());
+        if (idx === groupMetas.length - 1) return title;
+        return padEndVisible(title, m.totalWidth);
+      })
+      .join(" ".repeat(groupGap));
+    lines.push(" ".repeat(indent) + titleLine);
+
+    const maxRows = Math.max(...groupMetas.map((m) => m.group.pairs.length));
+    for (let r = 0; r < maxRows; r++) {
+      const parts = groupMetas.map((m, idx) => {
+        const pair = m.group.pairs[r];
+        if (!pair) {
+          if (idx === groupMetas.length - 1) return "";
+          return " ".repeat(m.totalWidth);
+        }
+        const [key, val] = pair;
+        const paddedKey = theme.label(key.padEnd(m.keyWidth));
+        const paddedVal = padEndVisible(val, m.valWidth);
+        if (idx === groupMetas.length - 1) return `${paddedKey}  ${val}`;
+        return `${paddedKey}  ${paddedVal}`;
+      });
+      const line = parts.join(" ".repeat(groupGap));
+      lines.push(" ".repeat(indent) + line);
+    }
+  }
+
+  return lines;
+}
+
+export function printMultiColumnKV(groups: KVGroup[]): void {
+  for (const line of renderMultiColumnKV(groups)) console.log(line);
+}
+
+// ── Plugin card (compact inline) ─────────────────────────────────
+
+export interface PluginCardOpts {
+  name: string;
+  pairs: [string, string][];
+  methods?: string[];
+}
+
+export function renderPluginCard(opts: PluginCardOpts, width?: number): string[] {
+  const w = width ?? termWidth();
+  const indentStr = "    ";
+  const maxLineWidth = w - indentStr.length;
+  const sep = "  ";
+  const lines: string[] = [];
+
+  lines.push("");
+  lines.push(`  ${theme.sectionHeader(opts.name)}`);
+
+  const items = opts.pairs.map(([k, v]) => `${theme.label(k + ":")} ${v}`);
+  let current = "";
+
+  for (const item of items) {
+    const candidateLen = current ? visibleLength(current) + sep.length + visibleLength(item) : visibleLength(item);
+    if (current && candidateLen > maxLineWidth) {
+      lines.push(indentStr + current);
+      current = item;
+    } else {
+      current = current ? current + sep + item : item;
+    }
+  }
+  if (current) lines.push(indentStr + current);
+
+  if (opts.methods && opts.methods.length > 0) {
+    lines.push(indentStr + theme.label("Methods:") + " " + opts.methods.join(", "));
+  }
+
+  return lines;
+}
+
+export function printPluginCard(opts: PluginCardOpts): void {
+  for (const line of renderPluginCard(opts)) console.log(line);
+}

package/src/sdk.ts

@@ -0,0 +1,37 @@
+import { AlgorandClient } from "@algorandfoundation/algokit-utils/types/algorand-client";
+import { Address, makeEmptyTransactionSigner } from "algosdk";
+import { setCurrentNetwork, type AkitaNetwork, AkitaDaoSDK } from "@akta/sdk";
+
+const ALGOD_URLS: Record<AkitaNetwork, string> = {
+  mainnet: "https://mainnet-api.algonode.cloud",
+  testnet: "https://testnet-api.algonode.cloud",
+  localnet: "http://localhost",
+};
+
+const ALGOD_PORTS: Record<AkitaNetwork, number> = {
+  mainnet: 443,
+  testnet: 443,
+  localnet: 4001,
+};
+
+export function createDAO(network: AkitaNetwork): AkitaDaoSDK {
+  setCurrentNetwork(network);
+
+  const algorand = AlgorandClient.fromConfig({
+    algodConfig: {
+      server: ALGOD_URLS[network],
+      port: ALGOD_PORTS[network],
+      token: "",
+    },
+  });
+
+  const READER = Address.fromString("Y76M3MSY6DKBRHBL7C3NNDXGS5IIMQVQVUAB6MP4XEMMGVF2QWNPL226CA");
+
+  return new AkitaDaoSDK({
+    algorand,
+    factoryParams: {
+      defaultSender: READER,
+      defaultSigner: makeEmptyTransactionSigner(),
+    },
+  });
+}

package/src/theme.ts

@@ -0,0 +1,73 @@
+import chalk from "chalk";
+
+// ── Akita brand palette ──────────────────────────────────────────
+
+const purple = chalk.hex("#9439e6");
+const pink = chalk.hex("#f35ff2");
+const green = chalk.hex("#44f8bd");
+const gold = chalk.hex("#f5c434");
+const yellow = chalk.hex("#FFEB00");
+const darkBlue = chalk.hex("#0039CB");
+const lightBlue = chalk.hex("#00F0FF");
+
+// ── Theme tokens ─────────────────────────────────────────────────
+
+const theme = {
+  // UI chrome
+  border: chalk.dim,
+  panelTitle: chalk.bold.hex("#9439e6"),
+  appName: chalk.bold.hex("#f35ff2"),
+  activeTab: chalk.bgHex("#9439e6").white.bold,
+  inactiveTab: chalk.dim,
+  tabSeparator: chalk.dim,
+  separator: chalk.dim,
+  statusBar: chalk.inverse,
+  sectionHeader: chalk.bold.hex("#9439e6"),
+
+  // KV / table labels
+  label: chalk.dim,
+
+  // Selection / navigation
+  cursor: pink,
+  selected: chalk.bold,
+
+  // Status colors
+  statusApproved: green,
+  statusVoting: lightBlue,
+  statusDraft: gold,
+  statusRejected: chalk.red,
+  stateActive: green,
+  stateInactive: chalk.red,
+  statePaused: gold,
+  boolTrue: green,
+  boolFalse: chalk.dim,
+
+  // Proposal action colors
+  actionAdd: green,
+  actionRemove: chalk.red,
+  actionModify: gold,
+
+  // Escrow status
+  locked: chalk.red,
+  unlocked: green,
+
+  // Compact number suffixes
+  suffixK: chalk.bold.white,
+  suffixM: green,
+  suffixB: lightBlue,
+  suffixT: purple,
+
+  // Charts
+  barFilled: lightBlue,
+  barEmpty: chalk.dim,
+  chartLabel: chalk.bold,
+  chartDim: chalk.dim,
+
+  // Revenue split segment palette (cycled)
+  splitColors: [purple, pink, green, gold, lightBlue, darkBlue, yellow],
+
+  // Global caller
+  globalCaller: green,
+};
+
+export default theme;