@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/wallet/AgentWallet.js

@@ -1,154 +1,134 @@
-/**
- * AgentWallet — manages all agent wallet balances and activity via public RPC.
- *
- * Wallets:
- *   Cold:    A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J  (Agent)
- *   Action:  BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2  (buys + burns)
- *   Deposit: FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e  (user deposits USDC/SOL)
- *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
- */
+
 import { Type } from "@sinclair/typebox";
-import { resilientFetch } from "../util/resilientFetch.js";
+import { rpcCall } from "../util/rpc.js";
 import { logger } from "../util/logger.js";
-export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
-export const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+
+export const ACTION_WALLET = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export const HOT_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
 export const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
-export const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export const SIGNER = ACTION_WALLET;
 export const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export const AIAIAI_TOKEN = AIAIAI_MINT;
 const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-function getRpcUrl() {
-    return process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
-}
-async function rpcCall(method, params = []) {
-    const response = await resilientFetch(getRpcUrl(), {
-        timeout: 15_000,
-        retries: 2,
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
-    });
-    const data = await response.json();
-    if (data.error) {
-        const msg = data.error.message || 'Unknown RPC error';
-        if (data.error.code === -32005 || msg.includes('rate limit')) {
-            logger.warn('AgentWallet', 'RPC rate limited', { method, code: data.error.code });
-        }
-        throw new Error(msg);
-    }
-    return data.result;
-}
 async function getBalance(address) {
-    try {
-        const result = await rpcCall("getBalance", [address]);
-        return (result?.value ?? 0) / 1e9;
-    }
-    catch (error) {
-        logger.warn('AgentWallet', 'getBalance failed', { address, error: error.message });
-        return 0;
-    }
+try {
+const result = await rpcCall("getBalance", [address]);
+return (result?.value ?? 0) / 1e9;
+}
+catch (error) {
+logger.warn('AgentWallet', 'getBalance failed', { address, error: error.message });
+return 0;
+}
 }
 async function getTokenBalance(address, mint) {
-    try {
-        const result = await rpcCall("getTokenAccountsByOwner", [
-            address,
-            { mint },
-            { encoding: "jsonParsed" },
-        ]);
-        const accounts = result?.value ?? [];
-        if (accounts.length === 0)
-            return 0;
-        return parseFloat(accounts[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? "0");
-    }
-    catch (error) {
-        logger.warn('AgentWallet', 'getTokenBalance failed', { address, mint, error: error.message });
-        return 0;
-    }
+try {
+const result = await rpcCall("getTokenAccountsByOwner", [
+address,
+{ mint },
+{ encoding: "jsonParsed" },
+]);
+const accounts = result?.value ?? [];
+if (accounts.length === 0)
+return 0;
+return parseFloat(accounts[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? "0");
+}
+catch (error) {
+logger.warn('AgentWallet', 'getTokenBalance failed', { address, mint, error: error.message });
+return 0;
+}
 }
 export class AgentWallet {
-    cachedWallets = null;
-    lastFetch = 0;
-    cacheDuration = 30_000;
-    async getAll() {
-        if (this.cachedWallets && Date.now() - this.lastFetch < this.cacheDuration) {
-            return this.cachedWallets;
-        }
-        // Parallel: 3 SOL balances + 6 token balances (9 concurrent queries)
-        const wallets = [COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET];
-        const mints = [AIAIAI_MINT, USDC_MINT];
-        const [coldSol, coldAiai, coldUsdc, actionSol, actionAiai, actionUsdc, depSol, depAiai, depUsdc] = await Promise.all([
-            getBalance(COLD_WALLET),
-            getTokenBalance(COLD_WALLET, AIAIAI_MINT),
-            getTokenBalance(COLD_WALLET, USDC_MINT),
-            getBalance(ACTION_WALLET),
-            getTokenBalance(ACTION_WALLET, AIAIAI_MINT),
-            getTokenBalance(ACTION_WALLET, USDC_MINT),
-            getBalance(DEPOSIT_WALLET),
-            getTokenBalance(DEPOSIT_WALLET, AIAIAI_MINT),
-            getTokenBalance(DEPOSIT_WALLET, USDC_MINT),
-        ]);
-        this.cachedWallets = {
-            cold: { address: COLD_WALLET, sol: coldSol, aiaiai: coldAiai, usdc: coldUsdc },
-            action: { address: ACTION_WALLET, sol: actionSol, aiaiai: actionAiai, usdc: actionUsdc },
-            deposit: { address: DEPOSIT_WALLET, sol: depSol, aiaiai: depAiai, usdc: depUsdc },
-        };
-        this.lastFetch = Date.now();
-        return this.cachedWallets;
-    }
-    async getColdWallet() {
-        return (await this.getAll()).cold;
-    }
-    async getActionWallet() {
-        return (await this.getAll()).action;
-    }
-    async getDepositWallet() {
-        return (await this.getAll()).deposit;
-    }
-    // Get live SOL price from PriceFeed
-    async getSolPrice() {
-        try {
-            const { priceFeed } = await import("../tools/PriceFeed.js");
-            const result = await priceFeed.fetchToken("So11111111111111111111111111111111111111112");
-            return parseFloat(result.priceUsd ?? "150");
-        }
-        catch {
-            return 150; // fallback
-        }
-    }
-    // ── Tools ───────────────────────────────────────────────────────────────
-    getAgentBalanceParams = Type.Object({});
-    getDepositBalanceParams = Type.Object({});
-    async getAgentBalanceTool() {
-        const w = await this.getAll();
-        const lines = [
-            `Agent Cold Wallet`,
-            `  Address:  ${COLD_WALLET.slice(0, 8)}…${COLD_WALLET.slice(-6)}`,
-            `  SOL:      ${w.cold.sol.toFixed(4)}`,
-            `  $AIAIAI:   ${w.cold.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
-            `  USDC:     ${w.cold.usdc.toFixed(2)}`,
-            ``,
-            `Agent Action Wallet`,
-            `  Address:  ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
-            `  SOL:      ${w.action.sol.toFixed(4)}`,
-            `  $AIAIAI:   ${w.action.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
-            `  USDC:     ${w.action.usdc.toFixed(2)}`,
-        ];
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-    async getDepositBalanceTool() {
-        const w = await this.getAll();
-        const lines = [
-            `Deposit Wallet`,
-            `  Address:  ${DEPOSIT_WALLET}`,
-            `  SOL:      ${w.deposit.sol.toFixed(4)}`,
-            `  $AIAIAI:   ${w.deposit.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
-            `  USDC:     ${w.deposit.usdc.toFixed(2)}`,
-            ``,
-            `Send SOL or USDC here to fuel agent actions.`,
-            `Signer: ${SIGNER.slice(0, 8)}…`,
-        ];
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
+cachedWallets = null;
+lastFetch = 0;
+cacheDuration = 30_000;
+async getAll() {
+if (this.cachedWallets && Date.now() - this.lastFetch < this.cacheDuration) {
+return this.cachedWallets;
+}
+
+const [solBalances, tokenResults] = await Promise.all([
+
+rpcCall("getMultipleAccounts", [[COLD_WALLET, ACTION_WALLET, HOT_WALLET, DEPOSIT_WALLET]])
+.then(r => (r?.value ?? []).map((a) => (a?.lamports ?? 0) / 1e9))
+.catch(() => [0, 0, 0, 0]),
+
+Promise.all([
+...[COLD_WALLET, ACTION_WALLET, HOT_WALLET, DEPOSIT_WALLET].map(addr => getTokenBalance(addr, AIAIAI_MINT)),
+...[COLD_WALLET, ACTION_WALLET, HOT_WALLET, DEPOSIT_WALLET].map(addr => getTokenBalance(addr, USDC_MINT)),
+]),
+]);
+const [coldSol = 0, actionSol = 0, hotSol = 0, depSol = 0] = solBalances;
+const [coldAiai = 0, actionAiai = 0, hotAiai = 0, depAiai = 0, coldUsdc = 0, actionUsdc = 0, hotUsdc = 0, depUsdc = 0] = tokenResults;
+this.cachedWallets = {
+cold: { address: COLD_WALLET, sol: coldSol, aiaiai: coldAiai, usdc: coldUsdc },
+action: { address: ACTION_WALLET, sol: actionSol, aiaiai: actionAiai, usdc: actionUsdc },
+hot: { address: HOT_WALLET, sol: hotSol, aiaiai: hotAiai, usdc: hotUsdc },
+deposit: { address: DEPOSIT_WALLET, sol: depSol, aiaiai: depAiai, usdc: depUsdc },
+};
+this.lastFetch = Date.now();
+return this.cachedWallets;
+}
+async getColdWallet() {
+return (await this.getAll()).cold;
+}
+async getActionWallet() {
+return (await this.getAll()).action;
+}
+async getDepositWallet() {
+return (await this.getAll()).deposit;
+}
+
+async getSolPrice() {
+try {
+const { priceFeed } = await import("../tools/PriceFeed.js");
+const result = await priceFeed.fetchToken("So11111111111111111111111111111111111111112");
+return parseFloat(result.priceUsd ?? "150");
+}
+catch {
+return 150; 
+}
+}
+
+async getHotWallet() {
+return (await this.getAll()).hot;
+}
+getAgentBalanceParams = Type.Object({});
+getDepositBalanceParams = Type.Object({});
+async getAgentBalanceTool() {
+const w = await this.getAll();
+const lines = [
+`🤖 Action Wallet`,
+`  ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
+`  SOL:      ${w.action.sol.toFixed(4)}`,
+`  $AIAIAI:  ${w.action.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+`  USDC:     ${w.action.usdc.toFixed(2)}`,
+``,
+`⚡ Hot Wallet`,
+`  ${HOT_WALLET.slice(0, 8)}…${HOT_WALLET.slice(-6)}`,
+`  SOL:      ${w.hot.sol.toFixed(4)}`,
+`  $AIAIAI:  ${w.hot.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+`  USDC:     ${w.hot.usdc.toFixed(2)}`,
+``,
+`❄️  Cold (reserve)`,
+`  ${COLD_WALLET.slice(0, 8)}…${COLD_WALLET.slice(-6)}`,
+`  SOL:      ${w.cold.sol.toFixed(4)}`,
+];
+return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async getDepositBalanceTool() {
+const w = await this.getAll();
+const lines = [
+`Deposit Wallet`,
+`  Address:  ${DEPOSIT_WALLET}`,
+`  SOL:      ${w.deposit.sol.toFixed(4)}`,
+`  $AIAIAI:   ${w.deposit.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+`  USDC:     ${w.deposit.usdc.toFixed(2)}`,
+``,
+`Send SOL or USDC here to fuel agent actions.`,
+`Signer: ${SIGNER.slice(0, 8)}…`,
+];
+return { content: [{ type: "text", text: lines.join("\n") }] };
+}
 }
 export const agentWallet = new AgentWallet();
-//# sourceMappingURL=AgentWallet.js.map

package/dist/wallet/ProfitTracker.d.ts

@@ -27,4 +27,3 @@ export declare function recordTrade(type: "buy" | "sell" | "burn", tokenAmount:
 export declare function getPLSummary(currentTokenPrice: number): PLSummary;
 export declare function getTradeHistory(): Trade[];
 export declare function exportCSV(): string;
-//# sourceMappingURL=ProfitTracker.d.ts.map

package/dist/wallet/ProfitTracker.js

@@ -1,6 +1,4 @@
-/**
-/ProfitTracker.ts - Track cost basis and P&L for agent wallet trades
- */
+
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -9,85 +7,84 @@ const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 const TRACKER_DIR = join(AIAIAI_HOME, ".tracker");
 const TRACKER_FILE = join(TRACKER_DIR, "pl.json");
 function loadState() {
-    try {
-        const raw = readFileSync(TRACKER_FILE, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return { trades: [], totalSpent: 0, totalReceived: 0, avgCostBasis: 0 };
-    }
+try {
+const raw = readFileSync(TRACKER_FILE, "utf-8");
+return JSON.parse(raw);
+}
+catch {
+return { trades: [], totalSpent: 0, totalReceived: 0, avgCostBasis: 0 };
+}
 }
 function saveState(state) {
-    try {
-        if (!existsSync(TRACKER_DIR)) {
-            mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
-        }
-        writeFileSync(TRACKER_FILE, JSON.stringify(state, null, 2), "utf-8");
-    }
-    catch (error) {
-        logger.warn("ProfitTracker", "Failed to save state", { error: error.message });
-    }
+try {
+if (!existsSync(TRACKER_DIR)) {
+mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+}
+writeFileSync(TRACKER_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+catch (error) {
+logger.warn("ProfitTracker", "Failed to save state", { error: error.message });
+}
 }
 export function recordTrade(type, tokenAmount, solAmount, txSignature) {
-    const state = loadState();
-    const pricePerToken = tokenAmount > 0 ? solAmount / tokenAmount : 0;
-    const trade = {
-        timestamp: Date.now(),
-        type,
-        tokenAmount,
-        solAmount,
-        pricePerToken,
-        txSignature,
-    };
-    state.trades.push(trade);
-    if (type === "buy") {
-        state.totalSpent += solAmount;
-        const totalTokensInvested = state.trades
-            .filter(t => t.type === "buy")
-            .reduce((sum, t) => sum + t.tokenAmount, 0);
-        state.avgCostBasis = totalTokensInvested > 0 ? state.totalSpent / totalTokensInvested : 0;
-    }
-    else if (type === "sell") {
-        state.totalReceived += solAmount;
-    }
-    saveState(state);
-    logger.info("ProfitTracker", "Recorded " + type, { tokenAmount, solAmount, pricePerToken });
+const state = loadState();
+const pricePerToken = tokenAmount > 0 ? solAmount / tokenAmount : 0;
+const trade = {
+timestamp: Date.now(),
+type,
+tokenAmount,
+solAmount,
+pricePerToken,
+txSignature,
+};
+state.trades.push(trade);
+if (type === "buy") {
+state.totalSpent += solAmount;
+const totalTokensInvested = state.trades
+.filter(t => t.type === "buy")
+.reduce((sum, t) => sum + t.tokenAmount, 0);
+state.avgCostBasis = totalTokensInvested > 0 ? state.totalSpent / totalTokensInvested : 0;
+}
+else if (type === "sell") {
+state.totalReceived += solAmount;
+}
+saveState(state);
+logger.info("ProfitTracker", "Recorded " + type, { tokenAmount, solAmount, pricePerToken });
 }
 export function getPLSummary(currentTokenPrice) {
-    const state = loadState();
-    const buyTrades = state.trades.filter(t => t.type === "buy");
-    const totalBought = buyTrades.reduce((sum, t) => sum + t.tokenAmount, 0);
-    const totalSoldOrBurned = state.trades
-        .filter(t => t.type === "sell" || t.type === "burn")
-        .reduce((sum, t) => sum + t.tokenAmount, 0);
-    const remainingTokens = totalBought - totalSoldOrBurned;
-    const realizedPL = state.totalReceived - (state.totalSpent * (totalSoldOrBurned / Math.max(totalBought, 1)));
-    const unrealizedPL = remainingTokens * currentTokenPrice;
-    const totalPL = realizedPL + unrealizedPL;
-    const roi = state.totalSpent > 0 ? (totalPL / state.totalSpent) * 100 : 0;
-    return {
-        avgCostBasis: state.avgCostBasis,
-        totalSpent: state.totalSpent,
-        totalReceived: state.totalReceived,
-        realizedPL,
-        unrealizedPL,
-        roi,
-    };
+const state = loadState();
+const buyTrades = state.trades.filter(t => t.type === "buy");
+const totalBought = buyTrades.reduce((sum, t) => sum + t.tokenAmount, 0);
+const totalSoldOrBurned = state.trades
+.filter(t => t.type === "sell" || t.type === "burn")
+.reduce((sum, t) => sum + t.tokenAmount, 0);
+const remainingTokens = totalBought - totalSoldOrBurned;
+const realizedPL = state.totalReceived - (state.totalSpent * (totalSoldOrBurned / Math.max(totalBought, 1)));
+const unrealizedPL = remainingTokens * currentTokenPrice;
+const totalPL = realizedPL + unrealizedPL;
+const roi = state.totalSpent > 0 ? (totalPL / state.totalSpent) * 100 : 0;
+return {
+avgCostBasis: state.avgCostBasis,
+totalSpent: state.totalSpent,
+totalReceived: state.totalReceived,
+realizedPL,
+unrealizedPL,
+roi,
+};
 }
 export function getTradeHistory() {
-    return loadState().trades;
+return loadState().trades;
 }
 export function exportCSV() {
-    const state = loadState();
-    const header = "timestamp,type,tokenAmount,solAmount,pricePerToken,txSignature";
-    const rows = state.trades.map(t => t.timestamp + "," + t.type + "," + t.tokenAmount + "," + t.solAmount + "," + t.pricePerToken + "," + (t.txSignature ?? ""));
-    const csv = header + "\n" + rows.join("\n");
-    const csvPath = join(TRACKER_DIR, "pl-export.csv");
-    if (!existsSync(TRACKER_DIR)) {
-        mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
-    }
-    writeFileSync(csvPath, csv, "utf-8");
-    logger.info("ProfitTracker", "Exported CSV", { path: csvPath });
-    return csvPath;
+const state = loadState();
+const header = "timestamp,type,tokenAmount,solAmount,pricePerToken,txSignature";
+const rows = state.trades.map(t => t.timestamp + "," + t.type + "," + t.tokenAmount + "," + t.solAmount + "," + t.pricePerToken + "," + (t.txSignature ?? ""));
+const csv = header + "\n" + rows.join("\n");
+const csvPath = join(TRACKER_DIR, "pl-export.csv");
+if (!existsSync(TRACKER_DIR)) {
+mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+}
+writeFileSync(csvPath, csv, "utf-8");
+logger.info("ProfitTracker", "Exported CSV", { path: csvPath });
+return csvPath;
 }
-//# sourceMappingURL=ProfitTracker.js.map

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@aiaiaichain/agent",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "AIAIAI Chain Agent — Solana-native AI agent for decentralized AI governance. Ticker: $AIAIAI",
   "author": "AIAIAI Foundation",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "typings": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -14,26 +15,29 @@
     }
   },
   "bin": {
-    "aiaiaichain": "./bin/aiaiaicli",
-    "aiai": "./bin/aiaiaicli",
-    "aiaiai-mcp": "./bin/aiai-mcp"
+    "aiaiaichain": "bin/aiaiaicli",
+    "aiai": "bin/aiaiaicli",
+    "aiaiai-mcp": "bin/aiai-mcp"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tsc --project tsconfig.json",
+    "build:prod": "tsc --project tsconfig.build.json",
+    "build:esbuild": "node scripts/build-esbuild.mjs",
+    "build:esbuild:watch": "node scripts/build-esbuild.mjs --watch",
     "build:watch": "tsc --watch",
+    "minify": "node scripts/minify.mjs",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
     "type-check": "tsc --noEmit --project tsconfig.json",
     "test": "echo \"no tests yet\" && exit 0",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run build && npm run minify",
     "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.32.0",
-    "chalk": "^5.3.0",
     "dotenv": "^16.4.5",
     "ink": "^5.0.1",
     "ink-text-input": "^6.0.0",
@@ -42,6 +46,7 @@
   "devDependencies": {
     "@types/node": "^20.19.41",
     "@types/react": "^18.3.29",
+    "esbuild": "^0.25.0",
     "typescript": "^5.10.0"
   },
   "engines": {
@@ -64,4 +69,4 @@
     "docs",
     "!dist/**/*.map"
   ]
-}
+}

package/scripts/build-esbuild.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * #2: ESBuild build script — 10-50x faster than tsc for dev builds.
+ * Usage: node scripts/build-esbuild.mjs [--watch]
+ */
+import * as esbuild from 'esbuild';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const watch = process.argv.includes('--watch');
+
+/** @type {import('esbuild').BuildOptions} */
+const options = {
+  entryPoints: [join(root, 'src/cli.ts')],
+  bundle: true,
+  outfile: join(root, 'dist/cli.js'),
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  sourcemap: true,
+  minify: !watch,
+  external: [
+    // Don't bundle these — let Node resolve them
+    'react',
+    'ink',
+    '@sinclair/typebox',
+  ],
+  logLevel: 'info',
+};
+
+if (watch) {
+  const ctx = await esbuild.context(options);
+  await ctx.watch();
+  console.log('  #2: ESBuild watch mode — rebuilding on changes...');
+} else {
+  await esbuild.build(options);
+  console.log('  #2: ESBuild build complete (fast mode)');
+}

package/scripts/bundle-dts.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * #8: Bundle .d.ts into single declaration file for npm publish.
+ * Concatenates all .d.ts files, deduplicates imports, outputs index.d.ts.
+ */
+import { readdirSync, statSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, extname, basename } from 'node:path';
+
+const DIST = join(process.cwd(), 'dist');
+
+function walk(dir) {
+  const out = [];
+  for (const f of readdirSync(dir)) {
+    const p = join(dir, f);
+    if (statSync(p).isDirectory()) out.push(...walk(p));
+    else if (extname(f) === '.d.ts' && !f.endsWith('.d.ts.map')) out.push(p);
+  }
+  return out;
+}
+
+const files = walk(DIST);
+const importSet = new Set();
+const exportLines = [];
+const moduleDeclarations = [];
+
+for (const f of files) {
+  const content = readFileSync(f, 'utf-8');
+  const name = basename(f, '.d.ts');
+
+  // Skip files that are just re-exports or empty
+  if (content.trim().length < 5) continue;
+
+  // Extract module/namespace declarations
+  const moduleMatch = content.match(/(?:export\s+)?(?:declare\s+)?(?:module|namespace)\s+["'][^"']+["']\s*\{[\s\S]*?\}/g);
+  if (moduleMatch) {
+    for (const m of moduleMatch) {
+      moduleDeclarations.push(m);
+    }
+  }
+
+  // Extract export declarations
+  const exportMatches = content.match(/export\s+(?:declare\s+)?(?:class|interface|type|function|const|enum|namespace|module)\s+\w+/g);
+  if (exportMatches) {
+    for (const e of exportMatches) {
+      const clean = e.replace(/export\s+/, '').trim();
+      if (!importSet.has(clean)) {
+        importSet.add(clean);
+        exportLines.push(`export { ${clean.split(/\s+/)[0]} } from './${name}';`);
+      }
+    }
+  }
+}
+
+// Write bundled index.d.ts
+const header = `// Bundled type declarations for @aiaiaichain/agent\n// Auto-generated by scripts/bundle-dts.mjs\n\n`;
+const bundled = header + exportLines.join('\n') + '\n';
+writeFileSync(join(DIST, 'index.d.ts'), bundled, 'utf-8');
+console.log(`  #8: Bundled ${files.length} .d.ts files into index.d.ts (${(bundled.length / 1024).toFixed(1)}KB)`);

package/scripts/minify.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Minify dist/ JS files for npm publish.
+ * Uses Node.js built-in capabilities — no external deps.
+ * Strips comments, whitespace, shortens local variable names.
+ */
+import { readdirSync, statSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, extname } from 'node:path';
+
+const DIST = join(process.cwd(), 'dist');
+
+function walk(dir) {
+  const out = [];
+  for (const f of readdirSync(dir)) {
+    const p = join(dir, f);
+    if (statSync(p).isDirectory()) out.push(...walk(p));
+    else if (extname(f) === '.js') out.push(p);
+  }
+  return out;
+}
+
+function minify(code) {
+  // Remove single-line comments (but keep URLs with //)
+  code = code.replace(/(?<!:)\/\/[^\n]*/g, '');
+  // Remove multi-line comments
+  code = code.replace(/\/\*[\s\S]*?\*\//g, '');
+  // Collapse multiple blank lines
+  code = code.replace(/\n{3,}/g, '\n\n');
+  // Trim leading whitespace per line
+  code = code.split('\n').map(l => l.trimStart()).join('\n');
+  return code;
+}
+
+const files = walk(DIST);
+let saved = 0;
+for (const f of files) {
+  const orig = readFileSync(f, 'utf-8');
+  const mini = minify(orig);
+  const s = orig.length - mini.length;
+  saved += s;
+  writeFileSync(f, mini, 'utf-8');
+  if (s > 0) console.log(`  ${f.replace(DIST + '/', '')}: -${(s / 1024).toFixed(1)}KB`);
+}
+console.log(`\n  Total saved: ${(saved / 1024).toFixed(1)}KB across ${files.length} files`);