chainlesschain 0.37.9 → 0.37.10

package/src/lib/wallet-manager.js

@@ -0,0 +1,348 @@
+/**
+ * Wallet Manager — Digital wallet and asset management for CLI.
+ * Uses Node.js crypto for key generation. Blockchain operations
+ * are local-only (no real chain interaction without bridge).
+ */
+
+import crypto from "crypto";
+
+/**
+ * Ensure wallet tables exist.
+ */
+export function ensureWalletTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS wallets (
+      address TEXT PRIMARY KEY,
+      name TEXT,
+      wallet_type TEXT DEFAULT 'standard',
+      public_key TEXT NOT NULL,
+      encrypted_key TEXT NOT NULL,
+      balance TEXT DEFAULT '0',
+      is_default INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS digital_assets (
+      id TEXT PRIMARY KEY,
+      wallet_address TEXT NOT NULL,
+      asset_type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      metadata TEXT,
+      amount TEXT DEFAULT '1',
+      status TEXT DEFAULT 'active',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS transactions (
+      id TEXT PRIMARY KEY,
+      from_address TEXT,
+      to_address TEXT,
+      asset_id TEXT,
+      amount TEXT NOT NULL,
+      tx_type TEXT NOT NULL,
+      status TEXT DEFAULT 'pending',
+      metadata TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/**
+ * Generate a wallet address from public key.
+ */
+export function generateAddress(publicKeyHex) {
+  const hash = crypto
+    .createHash("sha256")
+    .update(Buffer.from(publicKeyHex, "hex"))
+    .digest();
+  return `0x${hash.toString("hex").slice(0, 40)}`;
+}
+
+/**
+ * Create a new wallet.
+ */
+export function createWallet(db, name, password) {
+  ensureWalletTables(db);
+
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" },
+  });
+
+  const publicKeyHex = publicKey.toString("hex");
+  const address = generateAddress(publicKeyHex);
+
+  // Encrypt private key with password
+  const salt = crypto.randomBytes(16);
+  const key = crypto.pbkdf2Sync(
+    password || "default",
+    salt,
+    100000,
+    32,
+    "sha256",
+  );
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(privateKey), cipher.final()]);
+  const tag = cipher.getAuthTag();
+
+  const encryptedKey = JSON.stringify({
+    salt: salt.toString("hex"),
+    iv: iv.toString("hex"),
+    data: encrypted.toString("hex"),
+    tag: tag.toString("hex"),
+  });
+
+  // First wallet is default
+  const count = db.prepare("SELECT COUNT(*) as c FROM wallets").get().c;
+  const isDefault = count === 0 ? 1 : 0;
+
+  db.prepare(
+    `INSERT INTO wallets (address, name, wallet_type, public_key, encrypted_key, balance, is_default)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    address,
+    name || null,
+    "standard",
+    publicKeyHex,
+    encryptedKey,
+    "0",
+    isDefault,
+  );
+
+  return {
+    address,
+    name,
+    walletType: "standard",
+    publicKey: publicKeyHex,
+    balance: "0",
+    isDefault: isDefault === 1,
+  };
+}
+
+/**
+ * Get a wallet by address.
+ */
+export function getWallet(db, address) {
+  ensureWalletTables(db);
+  return db.prepare("SELECT * FROM wallets WHERE address = ?").get(address);
+}
+
+/**
+ * Get the default wallet.
+ */
+export function getDefaultWallet(db) {
+  ensureWalletTables(db);
+  return db.prepare("SELECT * FROM wallets WHERE is_default = 1").get();
+}
+
+/**
+ * Get all wallets.
+ */
+export function getAllWallets(db) {
+  ensureWalletTables(db);
+  return db
+    .prepare("SELECT * FROM wallets ORDER BY is_default DESC, created_at DESC")
+    .all();
+}
+
+/**
+ * Set a wallet as default.
+ */
+export function setDefaultWallet(db, address) {
+  ensureWalletTables(db);
+  const wallet = getWallet(db, address);
+  if (!wallet) return false;
+
+  db.prepare("UPDATE wallets SET is_default = 0 WHERE address LIKE ?").run("%");
+  db.prepare("UPDATE wallets SET is_default = 1 WHERE address = ?").run(
+    address,
+  );
+  return true;
+}
+
+/**
+ * Delete a wallet.
+ */
+export function deleteWallet(db, address) {
+  ensureWalletTables(db);
+  const result = db
+    .prepare("DELETE FROM wallets WHERE address = ?")
+    .run(address);
+  if (result.changes > 0) {
+    // Promote next wallet to default
+    const next = db
+      .prepare("SELECT address FROM wallets ORDER BY created_at ASC LIMIT 1")
+      .get();
+    if (next) {
+      db.prepare("UPDATE wallets SET is_default = 1 WHERE address = ?").run(
+        next.address,
+      );
+    }
+  }
+  return result.changes > 0;
+}
+
+/**
+ * Get wallet balance.
+ */
+export function getBalance(db, address) {
+  ensureWalletTables(db);
+  const wallet = getWallet(db, address);
+  if (!wallet) return null;
+  return { address, balance: wallet.balance, name: wallet.name };
+}
+
+/**
+ * Create a digital asset.
+ */
+export function createAsset(
+  db,
+  walletAddress,
+  assetType,
+  name,
+  description,
+  metadata,
+) {
+  ensureWalletTables(db);
+  const wallet = getWallet(db, walletAddress);
+  if (!wallet) throw new Error(`Wallet not found: ${walletAddress}`);
+
+  const id = `asset-${crypto.randomBytes(8).toString("hex")}`;
+
+  db.prepare(
+    `INSERT INTO digital_assets (id, wallet_address, asset_type, name, description, metadata, amount, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    walletAddress,
+    assetType,
+    name,
+    description || null,
+    metadata ? JSON.stringify(metadata) : null,
+    "1",
+    "active",
+  );
+
+  return {
+    id,
+    walletAddress,
+    assetType,
+    name,
+    description,
+    amount: "1",
+    status: "active",
+  };
+}
+
+/**
+ * Get assets for a wallet.
+ */
+export function getAssets(db, walletAddress) {
+  ensureWalletTables(db);
+  return db
+    .prepare(
+      "SELECT * FROM digital_assets WHERE wallet_address = ? ORDER BY created_at DESC",
+    )
+    .all(walletAddress);
+}
+
+/**
+ * Get all assets across all wallets.
+ */
+export function getAllAssets(db) {
+  ensureWalletTables(db);
+  return db
+    .prepare("SELECT * FROM digital_assets ORDER BY created_at DESC")
+    .all();
+}
+
+/**
+ * Get asset by ID.
+ */
+export function getAsset(db, assetId) {
+  ensureWalletTables(db);
+  return db.prepare("SELECT * FROM digital_assets WHERE id = ?").get(assetId);
+}
+
+/**
+ * Transfer an asset to another wallet.
+ */
+export function transferAsset(db, assetId, toAddress, amount) {
+  ensureWalletTables(db);
+  const asset = getAsset(db, assetId);
+  if (!asset) throw new Error(`Asset not found: ${assetId}`);
+
+  const txId = `tx-${crypto.randomBytes(8).toString("hex")}`;
+  const fromAddress = asset.wallet_address;
+  const txAmount = amount || asset.amount;
+
+  db.prepare(
+    `INSERT INTO transactions (id, from_address, to_address, asset_id, amount, tx_type, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    txId,
+    fromAddress,
+    toAddress,
+    assetId,
+    txAmount,
+    "transfer",
+    "confirmed",
+  );
+
+  // Update asset ownership
+  db.prepare("UPDATE digital_assets SET wallet_address = ? WHERE id = ?").run(
+    toAddress,
+    assetId,
+  );
+
+  return {
+    txId,
+    from: fromAddress,
+    to: toAddress,
+    assetId,
+    amount: txAmount,
+    status: "confirmed",
+  };
+}
+
+/**
+ * Get transaction history.
+ */
+export function getTransactions(db, options = {}) {
+  ensureWalletTables(db);
+  const { address, limit = 50 } = options;
+
+  if (address) {
+    return db
+      .prepare(
+        "SELECT * FROM transactions WHERE from_address = ? OR to_address = ? ORDER BY created_at DESC LIMIT ?",
+      )
+      .all(address, address, limit);
+  }
+
+  return db
+    .prepare("SELECT * FROM transactions ORDER BY created_at DESC LIMIT ?")
+    .all(limit);
+}
+
+/**
+ * Get wallet summary.
+ */
+export function getWalletSummary(db) {
+  ensureWalletTables(db);
+  const wallets = db.prepare("SELECT COUNT(*) as c FROM wallets").get();
+  const assets = db.prepare("SELECT COUNT(*) as c FROM digital_assets").get();
+  const txns = db.prepare("SELECT COUNT(*) as c FROM transactions").get();
+
+  return {
+    walletCount: wallets?.c || 0,
+    assetCount: assets?.c || 0,
+    transactionCount: txns?.c || 0,
+  };
+}

package/src/repl/agent-repl.js

@@ -24,6 +24,7 @@ import path from "path";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { logger } from "../lib/logger.js";
+import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
 
 /**
  * Tool definitions for function calling
@@ -261,9 +262,29 @@ function loadSkillList(skillsDir) {
 }
 
 /**
- * Execute a tool call
+ * Execute a tool call (with plan mode filtering)
  */
 async function executeTool(name, args) {
+  // Plan mode: check if tool is allowed
+  const planManager = getPlanModeManager();
+  if (planManager.isActive() && !planManager.isToolAllowed(name)) {
+    // In plan mode, log the blocked tool as a plan item
+    planManager.addPlanItem({
+      title: `${name}: ${formatToolArgs(name, args)}`,
+      tool: name,
+      params: args,
+      estimatedImpact:
+        name === "run_shell"
+          ? "high"
+          : name === "write_file"
+            ? "medium"
+            : "low",
+    });
+    return {
+      error: `[Plan Mode] Tool "${name}" is blocked during planning. It has been added to the plan. Use /plan approve to execute.`,
+    };
+  }
+
   switch (name) {
     case "read_file": {
       const filePath = path.resolve(args.path);
@@ -520,6 +541,9 @@ async function chatWithTools(messages, options) {
 
     const data = await response.json();
     // Normalize to Ollama-like format
+    if (!data.choices || !data.choices[0]) {
+      throw new Error("Invalid API response: no choices returned");
+    }
     const choice = data.choices[0];
     return {
       message: choice.message,
@@ -537,7 +561,11 @@ async function agentLoop(messages, options) {
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
     const result = await chatWithTools(messages, options);
-    const msg = result.message;
+    const msg = result?.message;
+
+    if (!msg) {
+      return "(No response from LLM)";
+    }
 
     // Check for tool calls
     const toolCalls = msg.tool_calls;
@@ -643,10 +671,22 @@ export async function startAgentRepl(options = {}) {
 
   const messages = [{ role: "system", content: SYSTEM_PROMPT }];
 
+  const getPrompt = () => {
+    const planManager = getPlanModeManager();
+    if (planManager.isActive()) {
+      const state = planManager.state;
+      if (state === PlanState.APPROVED || state === PlanState.EXECUTING) {
+        return chalk.green("[plan:exec] > ");
+      }
+      return chalk.yellow("[plan] > ");
+    }
+    return chalk.green("> ");
+  };
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: chalk.green("> "),
+    prompt: getPrompt(),
     terminal: true,
   });
 
@@ -661,12 +701,16 @@ export async function startAgentRepl(options = {}) {
   );
   logger.log(chalk.gray("Type /exit to quit, /help for commands\n"));
 
-  rl.prompt();
+  const prompt = () => {
+    rl.setPrompt(getPrompt());
+    rl.prompt();
+  };
+  prompt();
 
   rl.on("line", async (input) => {
     const trimmed = input.trim();
     if (!trimmed) {
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -686,13 +730,21 @@ export async function startAgentRepl(options = {}) {
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(`  ${chalk.cyan("/compact")}    Keep only last 4 messages`);
+      logger.log(
+        `  ${chalk.cyan("/plan")}       Enter plan mode (read-only analysis first)`,
+      );
+      logger.log(`  ${chalk.cyan("/plan show")}  Show current plan`);
+      logger.log(
+        `  ${chalk.cyan("/plan approve")} Approve and execute the plan`,
+      );
+      logger.log(`  ${chalk.cyan("/plan reject")}  Reject the plan`);
       logger.log(chalk.bold("\nCapabilities:"));
       logger.log("  Read, write, and edit files");
       logger.log("  Run shell commands (git, npm, etc.)");
       logger.log("  Search codebase by filename or content");
       logger.log("  Run 138 built-in skills (code-review, summarize, etc.)");
-      logger.log("  Answer questions about code\n");
-      rl.prompt();
+      logger.log("  Plan mode: analyze first, execute after approval\n");
+      prompt();
       return;
     }
 
@@ -704,7 +756,7 @@ export async function startAgentRepl(options = {}) {
       } else {
         logger.info(`Current model: ${chalk.cyan(model)}`);
       }
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -716,14 +768,14 @@ export async function startAgentRepl(options = {}) {
       } else {
         logger.info(`Current provider: ${chalk.cyan(provider)}`);
       }
-      rl.prompt();
+      prompt();
       return;
     }
 
     if (trimmed === "/clear") {
       messages.length = 1; // Keep system prompt
       logger.info("Conversation cleared");
-      rl.prompt();
+      prompt();
       return;
     }
 
@@ -736,7 +788,85 @@ export async function startAgentRepl(options = {}) {
         messages.push(systemMsg, ...recent);
         logger.info("Conversation compacted to last 4 messages");
       }
-      rl.prompt();
+      prompt();
+      return;
+    }
+
+    // Plan mode commands
+    if (trimmed.startsWith("/plan")) {
+      const planManager = getPlanModeManager();
+      const subCmd = trimmed.slice(5).trim();
+
+      if (!subCmd || subCmd === "enter") {
+        if (planManager.isActive()) {
+          logger.info(
+            "Already in plan mode. Use /plan show, /plan approve, or /plan reject.",
+          );
+        } else {
+          planManager.enterPlanMode({ title: "Agent Plan" });
+          logger.success(
+            "Entered plan mode. Write tools are blocked until you approve the plan.",
+          );
+          logger.info(
+            "The AI can still read files and search. Blocked tools become plan items.",
+          );
+          logger.info(
+            "Use /plan show to see the plan, /plan approve to execute.",
+          );
+          // Inject plan mode context into system prompt
+          messages.push({
+            role: "system",
+            content:
+              "[PLAN MODE ACTIVE] You are now in plan mode. You can read files, search, and analyze — but write/execute tools are blocked. Any blocked tool calls will be recorded as plan items. Analyze the task thoroughly, then the user will approve your plan.",
+          });
+        }
+      } else if (subCmd === "show") {
+        if (!planManager.isActive()) {
+          logger.info("Not in plan mode. Use /plan to enter.");
+        } else {
+          logger.log("\n" + planManager.generatePlanSummary() + "\n");
+        }
+      } else if (subCmd === "approve" || subCmd === "yes") {
+        if (!planManager.isActive()) {
+          logger.info("No plan to approve.");
+        } else if (planManager.currentPlan.items.length === 0) {
+          logger.info(
+            "Plan has no items yet. Let the AI analyze the task first.",
+          );
+        } else {
+          planManager.approvePlan();
+          logger.success(
+            `Plan approved! ${planManager.currentPlan.items.length} items ready for execution.`,
+          );
+          logger.info(
+            "Write/execute tools are now unlocked. The AI can proceed.",
+          );
+          messages.push({
+            role: "system",
+            content: `[PLAN APPROVED] The user has approved your plan with ${planManager.currentPlan.items.length} items. You can now use all tools including write_file, edit_file, run_shell, and run_skill. Execute the plan items in order.`,
+          });
+        }
+      } else if (subCmd === "reject" || subCmd === "no") {
+        if (!planManager.isActive()) {
+          logger.info("No plan to reject.");
+        } else {
+          planManager.rejectPlan("User rejected");
+          logger.info("Plan rejected. Exited plan mode.");
+        }
+      } else if (subCmd === "exit") {
+        if (planManager.isActive()) {
+          planManager.exitPlanMode({ savePlan: true });
+          logger.info("Exited plan mode.");
+        } else {
+          logger.info("Not in plan mode.");
+        }
+      } else {
+        logger.info(
+          "Unknown /plan subcommand. Try: /plan, /plan show, /plan approve, /plan reject, /plan exit",
+        );
+      }
+
+      prompt();
       return;
     }
 
@@ -773,7 +903,7 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
-    rl.prompt();
+    prompt();
   });
 
   rl.on("close", () => {