thinyai 0.1.0 → 0.1.2

package/README.md

@@ -1,38 +1,162 @@
-# @thiny/cli
+# thinyai
 
-> Beautiful TUI agent CLI with interactive chat and tool execution
+> A beautiful terminal AI agent — interactive chat, tools, cross-session memory on **Walrus**, and grounded **Sui** execution. The command is `thiny`.
 
-[![npm](https://img.shields.io/npm/v/@thiny/cli)](https://www.npmjs.com/package/@thiny/cli)
+[![npm](https://img.shields.io/npm/v/thinyai)](https://www.npmjs.com/package/thinyai)
+
+```text
+ _____ _     _                _    ___
+|_   _| |__ (_)_ __  _   _   / \  |_ _|
+  | | | '_ \| | '_ \| | | | / _ \  | |
+  | | | | | | | | | | |_| |/ ___ \ | |
+  |_| |_| |_|_|_| |_|\__, /_/   \_\___|
+                     |___/
+```
+
+---
 
 ## Install
 
 ```bash
-pnpm add -g @thiny/cli
+bun add -g thinyai      # or:  npm i -g thinyai   /   pnpm add -g thinyai
 ```
 
-## Usage
+This installs one command: **`thiny`**. No `.env`, no config files to hand-edit — the first run sets you up.
 
 ```bash
-# Start interactive chat
-thiny
+thiny                   # first launch runs setup, then starts chatting
+```
+
+---
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `thiny` | Start the interactive agent. Runs first-time setup if needed. |
+| `thiny init` | (Re)run base setup — pick a model + agent name + API key. |
+| `thiny sui init` | Add Sui on-chain capabilities — pick a network + wallet. |
+| `thiny help` | Show all commands. |
+| `thiny --version` | Print the version. |
+
+Everything is saved to **`~/.thiny/config.json`** (chmod `0600` — it holds your API key and any Sui key). No `.env` required.
+
+---
+
+## First run / `thiny init`
+
+The first time you run `thiny` (or any time you run `thiny init`), an arrow-key wizard asks:
+
+1. **Agent name** — what the assistant calls itself (default `ThinyAI`).
+2. **Model** — pick from the list, or **Custom** for any OpenAI-compatible endpoint:
+
+   | Choice | Notes |
+   |---|---|
+   | OpenAI · gpt-4o-mini | fast, cheap |
+   | OpenAI · gpt-4o | |
+   | Anthropic · claude-haiku-4-5 | |
+   | Anthropic · claude-sonnet-4-6 | |
+   | Ollama | local, no key (`http://localhost:11434/v1`) |
+   | Custom | enter model id + base URL + key — works with Groq, Together, OpenRouter, LM Studio, vLLM, Mimo, Azure, … |
+
+3. **API key** — pasted securely (masked); skipped for keyless setups like Ollama.
+
+That's it — `thiny` starts.
+
+---
+
+## Sui setup / `thiny sui init`
+
+Adds grounded, capped on-chain execution. If you haven't run base setup yet, this runs it first.
+
+1. **Network** — `Testnet` (recommended) or `Mainnet`. You can change this later by re-running `thiny sui init`.
+2. **Wallet** — choose one:
+
+   | Option | What happens |
+   |---|---|
+   | **Paste an existing private key** | Enter a `suiprivkey…` key (masked). |
+   | **Generate a new key pair locally** | A fresh Ed25519 key is created and stored in your config. |
+   | **Agent wallet (Rill)** | Generates a signer key and stores your per-user Rill MCP URL for grounded execution. |
+
+After setup it prints your **address** — you must **fund it** before sending transactions:
 
-# With specific model
-thiny --model openai/gpt-4o
+```text
+⚠ Fund this address (testnet) before sending transactions
+  0xabc…
+  Faucet: https://faucet.sui.io   (or `sui client faucet`)
+```
+
+> Mainnet is gated: the signer refuses to sign on mainnet unless explicitly enabled, and per-tx / budget / expiry caps are enforced **on-chain** by the agent-wallet contract — the local policy is only a soft UX layer.
+
+---
+
+## In-chat commands
+
+While chatting, type a slash command:
+
+| Command | Description |
+|---|---|
+| `/new` | Start a fresh session (long-term memory carries over). |
+| `/tools` | List available tools. |
+| `/skills` | List available skills. |
+| `/session` | Show the current session id. |
+| `/stats` | Session totals (turns, tokens, tool calls). |
+| `/verify <blobId>` | Re-fetch and replay a stored Walrus audit trail. |
+| `/clear` | Clear the screen. |
+| `/help` | Show these commands. |
 
-# Non-interactive query
-thiny run "What is the ETH price?"
+Press **Ctrl-D** (or Ctrl-C) to exit.
+
+---
+
+## Memory (Walrus)
+
+Thiny remembers across sessions. Durable facts about you are stored on **Walrus** (content-addressed, verifiable, portable — not locked to one machine) and auto-injected at the start of each conversation. When a fact is saved you'll see a compact, verifiable line:
+
+```text
+✓ memory saved on Walrus · https://walruscan.com/testnet/blob/…
 ```
 
-## Features
+Writes are non-blocking — you can keep chatting while they upload. Set `MEMWAL_*` env vars to use MemWal (semantic memory) instead.
+
+---
+
+## Output
+
+Responses render as **markdown** in the terminal — bold, italics, `inline code`, lists, headings, blockquotes, fenced code blocks, and clickable `[links](url)`. Model reasoning (`<think>…</think>`) streams dimmed.
+
+---
+
+## Config reference
+
+`~/.thiny/config.json`:
+
+```jsonc
+{
+  "agentName": "ThinyAI",
+  "userId": "default",
+  "model": "openai:gpt-4o-mini",   // or "anthropic:…", or a bare id with baseUrl
+  "baseUrl": "https://…/v1",        // optional — for OpenAI-compatible endpoints
+  "apiKey": "sk-…",
+  "sui": {                          // present after `thiny sui init`
+    "network": "testnet",
+    "address": "0x…",
+    "wallet": { "type": "generated", "secretKey": "suiprivkey…" },
+    "rillMcpUrl": "https://…"       // optional — Rill agent wallet
+  }
+}
+```
+
+Environment variables override the config when set (handy for CI/dev): `THINY_MODEL`, `THINY_OPENAI_API_KEY`, `THINY_ANTHROPIC_API_KEY`, `THINY_OPENAI_BASE_URL`, `THINY_PERSONA_NAME`, `THINY_USER_ID`, `SUI_NETWORK`, `SUI_SECRET_KEY`, `MCP_URL`.
+
+---
 
-- Interactive TUI with ASCII art header
-- Streaming SSE responses
-- Multi-session support
-- Tool call visualization
-- EVM + Solana wallet integration
+## Troubleshooting
 
-[📖 Full docs →](https://github.com/thiny-ai/thiny/tree/main/heads/cli)
+- **`(model returned empty response)` / API error** — wrong model id, base URL, or key. Re-run `thiny init`, or edit `~/.thiny/config.json`. The CLI prints the underlying provider error.
+- **Transactions fail** — make sure the address from `thiny sui init` is funded.
+- **Logs** — written to `~/.thiny/cli.log` (never to the chat). Tail with `tail -f ~/.thiny/cli.log`.
 
 ---
 
-*Part of the [Thiny AI](https://github.com/thiny-ai/thiny) framework*
+*Part of the [Thiny](https://github.com/ESES-Labs/thinyai-walrus) framework — a tiny, hexagonal agent kernel for Web2 + Web3.*

package/dist/bin.js

@@ -2,8 +2,11 @@
 
 // src/main.ts
 import { createInterface } from "readline/promises";
-import { clearLine, cursorTo } from "readline";
+import { clearLine, cursorTo, emitKeypressEvents } from "readline";
 import { stdin, stdout } from "process";
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 import { z as z4 } from "zod";
 
 // ../../packages/core/src/domain/messages.ts
@@ -449,9 +452,9 @@ async function createAgent(config) {
     const seed = config.systemPrompt && !history.some((m) => m.role === "system") ? [systemMessage(config.systemPrompt), ...history] : history;
     const generate = composeModel(extensions.middleware.model, async (req) => {
       if (opts.onToken && config.model.stream) {
-        return assembleStream(config.model.stream(req.messages, req.tools), opts.onToken);
+        return assembleStream(config.model.stream(req.messages, req.tools, opts.signal), opts.onToken);
       }
-      return config.model.generate(req.messages, req.tools);
+      return config.model.generate(req.messages, req.tools, opts.signal);
     });
     const runComposedTool = composeTool(
       extensions.middleware.tool,
@@ -826,44 +829,38 @@ function buildToolOptions(tools) {
   if (tools.length === 0) return { tools: void 0, toolChoice: void 0 };
   return { tools: toAiTools(tools), toolChoice: "auto" };
 }
+var KNOWN_PROVIDERS = /* @__PURE__ */ new Set(["openai", "openai-compat", "anthropic"]);
 function resolveModel(model, opts) {
   if (typeof model !== "string") return model;
   const colonIdx = model.indexOf(":");
-  if (colonIdx === -1) {
-    if (opts.anthropic?.baseURL) {
-      return createAnthropic({ baseURL: opts.anthropic.baseURL, apiKey: opts.anthropic.apiKey })(
-        model
+  const prefix = colonIdx === -1 ? "" : model.slice(0, colonIdx);
+  if (KNOWN_PROVIDERS.has(prefix)) {
+    const modelId = model.slice(colonIdx + 1);
+    if (prefix === "anthropic") {
+      return createAnthropic({ baseURL: opts.anthropic?.baseURL, apiKey: opts.anthropic?.apiKey })(
+        modelId
       );
     }
-    return createOpenAI({ baseURL: opts.openai?.baseURL, apiKey: opts.openai?.apiKey })(model);
-  }
-  const provider = model.slice(0, colonIdx);
-  const modelId = model.slice(colonIdx + 1);
-  if (provider === "openai" || provider === "openai-compat") {
     return createOpenAI({ baseURL: opts.openai?.baseURL, apiKey: opts.openai?.apiKey })(modelId);
   }
-  if (provider === "anthropic") {
-    return createAnthropic({ baseURL: opts.anthropic?.baseURL, apiKey: opts.anthropic?.apiKey })(
-      modelId
+  if (opts.anthropic?.baseURL) {
+    return createAnthropic({ baseURL: opts.anthropic.baseURL, apiKey: opts.anthropic.apiKey })(
+      model
     );
   }
-  throw new Error(
-    `unknown provider "${provider}" in model string "${model}"
-Supported prefixes: "openai:<id>", "openai-compat:<id>", "anthropic:<id>"
-Or omit the prefix and set THINY_OPENAI_BASE_URL / THINY_ANTHROPIC_BASE_URL instead.
-Or pass a LanguageModel instance directly.`
-  );
+  return createOpenAI({ baseURL: opts.openai?.baseURL, apiKey: opts.openai?.apiKey })(model);
 }
 function aiSdkModel(opts) {
   const model = resolveModel(opts.model, opts);
   const maxRetries = opts.maxRetries ?? 2;
   return {
-    async generate(messages, tools) {
+    async generate(messages, tools, signal) {
       const result = await generateText({
         model,
         messages: toCoreMessages(messages),
         ...buildToolOptions(tools),
-        maxRetries
+        maxRetries,
+        abortSignal: signal
       });
       return {
         text: result.text || void 0,
@@ -877,12 +874,13 @@ function aiSdkModel(opts) {
         usage: normalizeUsage(result.usage)
       };
     },
-    async *stream(messages, tools) {
+    async *stream(messages, tools, signal) {
       const result = streamText({
         model,
         messages: toCoreMessages(messages),
         ...buildToolOptions(tools),
-        maxRetries
+        maxRetries,
+        abortSignal: signal
       });
       for await (const part of result.fullStream) {
         if (part.type === "text-delta") {
@@ -953,7 +951,7 @@ function pinoLogger(opts = {}) {
     );
   }
   if (opts.file) {
-    const destination = pino2.destination({ dest: opts.file, sync: false });
+    const destination = pino2.destination({ dest: opts.file, sync: true });
     return adaptPinoLogger(pino2(pinoConfig(level), destination));
   }
   const usePretty = opts.pretty ?? (opts.file === void 0 && process.env.NODE_ENV !== "production");
@@ -1792,8 +1790,10 @@ function parseSkillArgs() {
 }
 var currentSessionId = `cli-${(/* @__PURE__ */ new Date()).getTime().toString()}`;
 async function runCli() {
+  const thinyDir = join(homedir(), ".thiny");
+  mkdirSync(thinyDir, { recursive: true });
   const envLogFile = process.env.THINY_LOG_FILE?.trim();
-  const logFile = envLogFile && envLogFile.length > 0 ? envLogFile : `${process.env.HOME ?? "."}/thiny-cli.log`;
+  const logFile = envLogFile && envLogFile.length > 0 ? envLogFile : join(thinyDir, "cli.log");
   const fileLogger = pinoLogger({ level: process.env.LOG_LEVEL ?? "info", file: logFile });
   const turn = { inputTokens: 0, outputTokens: 0, toolCalls: 0, modelCalls: 0 };
   const session = { inputTokens: 0, outputTokens: 0, toolCalls: 0, turns: 0 };
@@ -1822,7 +1822,9 @@ async function runCli() {
     namespace: process.env.MEMWAL_NAMESPACE ?? userId
   }) : walrusMemoryPlugin({
     client: walrus,
-    pointers: filePointerStore(process.env.WALRUS_POINTERS ?? "thiny-pointers.json"),
+    // Stable per-user location (~/.thiny) so cross-session memory works no matter which
+    // directory `thiny` is launched from — a cwd-relative file would fragment per folder.
+    pointers: filePointerStore(process.env.WALRUS_POINTERS ?? join(thinyDir, "thiny-pointers.json")),
     userId,
     onStoreStart: () => pendingWrites += 1,
     onStore: (ref) => {
@@ -1894,6 +1896,7 @@ async function runCli() {
   if (walrusAudit)
     renderInfo(`Walrus audit: ON (${network}) \u2014 each turn's action log is stored + verifiable`);
   const rl = createInterface({ input: stdin, output: stdout });
+  emitKeypressEvents(stdin);
   const spinner = new Spinner();
   const flushMemory = memoryPlugin.flush;
   const PROMPT = "\x1B[36mYou\x1B[0m \x1B[2m\u203A\x1B[0m ";
@@ -2006,10 +2009,15 @@ Audit trail ${blobId}
         continue;
       }
       renderAgentLabel(personaName);
-      spinner.start("thinking\u2026");
+      spinner.start("thinking\u2026  (esc to cancel)");
       budget.reset();
       resetTurn(turn);
       const startedAt = Date.now();
+      const ac = new AbortController();
+      const onKey = (_s, key) => {
+        if (key?.name === "escape") ac.abort();
+      };
+      stdin.on("keypress", onKey);
       try {
         let firstToken = true;
         const stream = createMarkdownWriter((s) => stdout.write(s));
@@ -2021,15 +2029,28 @@ Audit trail ${blobId}
           spinner.start("running\u2026");
         };
         agent.events.on("beforeToolCall", toolHandler);
-        const reply = await agent.run(trimmed, {
-          sessionId: currentSessionId,
-          onToken: (delta) => {
+        let reply;
+        try {
+          reply = await agent.run(trimmed, {
+            sessionId: currentSessionId,
+            signal: ac.signal,
+            onToken: (delta) => {
+              spinner.stop();
+              firstToken = false;
+              stream.push(delta);
+            }
+          });
+        } catch (err) {
+          if (ac.signal.aborted) {
             spinner.stop();
-            firstToken = false;
-            stream.push(delta);
+            stream.end();
+            stdout.write("\n  \x1B[2m\u2298 cancelled (Esc)\x1B[0m\n");
+            continue;
           }
-        });
-        agent.events.off("beforeToolCall", toolHandler);
+          throw err;
+        } finally {
+          agent.events.off("beforeToolCall", toolHandler);
+        }
         spinner.stop();
         if (firstToken) {
           stream.push(reply.length > 0 ? reply : "\x1B[2m(model returned empty response)\x1B[0m");
@@ -2074,6 +2095,8 @@ Audit trail ${blobId}
           looksLikeModelError ? `${msg}
   \u21B3 Check your model, base URL, and API key (run \`thiny init\`, or edit ~/.thiny/config.json / .env).` : msg
         );
+      } finally {
+        stdin.off("keypress", onKey);
       }
     }
   } finally {
@@ -2082,16 +2105,16 @@ Audit trail ${blobId}
 }
 
 // src/onboarding.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, chmodSync } from "fs";
-import { homedir } from "os";
-import { join, dirname as dirname2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, chmodSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import * as p from "@clack/prompts";
-var THINY_DIR = join(homedir(), ".thiny");
-var CONFIG = join(THINY_DIR, "config.json");
+var THINY_DIR = join2(homedir2(), ".thiny");
+var CONFIG = join2(THINY_DIR, "config.json");
 function version() {
   try {
-    const pkg = join(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+    const pkg = join2(dirname2(fileURLToPath(import.meta.url)), "../package.json");
     return JSON.parse(readFileSync2(pkg, "utf8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -2101,7 +2124,7 @@ function loadConfig() {
   return existsSync2(CONFIG) ? JSON.parse(readFileSync2(CONFIG, "utf8")) : null;
 }
 function saveConfig(cfg) {
-  mkdirSync(THINY_DIR, { recursive: true });
+  mkdirSync2(THINY_DIR, { recursive: true });
   chmodSync(THINY_DIR, 448);
   writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
   chmodSync(CONFIG, 384);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinyai",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Thiny AI — a beautiful terminal agent: interactive chat, tools, Walrus memory, and Sui execution.",
   "type": "module",
   "license": "MIT",
@@ -36,14 +36,14 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.5.0",
-    "@thiny/core": "0.1.0",
-    "@thiny/mcp": "0.1.0",
-    "@thiny/model-aisdk": "0.1.0",
     "@thiny/logger-pino": "0.1.0",
+    "@thiny/model-aisdk": "0.1.0",
+    "@thiny/core": "0.1.0",
     "@thiny/memory-memwal": "0.1.0",
-    "@thiny/walrus": "0.1.0",
+    "@thiny/mcp": "0.1.0",
+    "@thiny/plugin-agents": "0.1.0",
     "@thiny/skills": "0.1.0",
-    "@thiny/plugin-agents": "0.1.0"
+    "@thiny/walrus": "0.1.0"
   },
   "author": "Thiny AI",
   "engines": {