@heyamiko/amiko-cli 0.4.0 → 0.4.7

package/src/config.ts

@@ -0,0 +1,31 @@
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { AppConfig } from "./types.js";
+
+function defaultWorkspacePath() {
+  return path.join(os.homedir(), ".amiko");
+}
+
+function newSessionId() {
+  return randomUUID().split("-")[0];
+}
+
+export function loadConfig(): AppConfig {
+  const workspacePath = process.env.AMIKO_WORKSPACE || defaultWorkspacePath();
+  const sessionId = process.env.AMIKO_SESSION_ID || newSessionId();
+
+  return {
+    workspacePath,
+    sessionId,
+    qmdBin: process.env.AMIKO_QMD_BIN || "qmd",
+    qmdLimit: Number(process.env.AMIKO_QMD_LIMIT || 5),
+    qmdEnabled: process.env.AMIKO_QMD_ENABLED !== "0",
+    qmdCollection: process.env.AMIKO_QMD_COLLECTION || undefined,
+    qmdFull: process.env.AMIKO_QMD_FULL === "1",
+    model: process.env.AMIKO_MODEL || undefined,
+    modelProvider: process.env.AMIKO_MODEL_PROVIDER || undefined,
+    modelId: process.env.AMIKO_MODEL_ID || undefined,
+    thinkingLevel: (process.env.AMIKO_THINKING_LEVEL as any) || undefined
+  };
+}

package/src/configFile.ts

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { AppConfig } from "./types.js";
+
+export type PersistedConfig = {
+  model?: string;
+  modelProvider?: string;
+  modelId?: string;
+  thinkingLevel?: AppConfig["thinkingLevel"];
+};
+
+export function getConfigFilePath(workspacePath: string) {
+  const base = workspacePath || path.join(os.homedir(), ".amiko");
+  return path.join(base, "config.json");
+}
+
+export async function loadConfigFile(workspacePath: string): Promise<PersistedConfig> {
+  const filePath = getConfigFilePath(workspacePath);
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw) as PersistedConfig;
+    return parsed || {};
+  } catch {
+    return {};
+  }
+}
+
+export async function saveConfigFile(workspacePath: string, config: PersistedConfig): Promise<void> {
+  const filePath = getConfigFilePath(workspacePath);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}

package/src/memory/qmd.ts

@@ -0,0 +1,111 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { MemoryHit } from "../types.js";
+
+const execFileAsync = promisify(execFile);
+
+function parseJsonLines(text: string) {
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const results: any[] = [];
+  for (const line of lines) {
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+      // ignore
+    }
+  }
+  return results;
+}
+
+export async function qmdSearch(options: {
+  qmdBin: string;
+  query: string;
+  limit: number;
+  collection?: string;
+}): Promise<MemoryHit[]> {
+  const { qmdBin, query, limit, collection } = options;
+
+  try {
+    const args = ["query", "--json", "-n", String(limit)];
+    if (collection) {
+      args.push("-c", collection);
+    }
+    args.push(query);
+
+    const { stdout } = await execFileAsync(qmdBin, [
+      ...args
+    ]);
+
+    try {
+      const parsed = JSON.parse(stdout);
+      if (Array.isArray(parsed)) {
+        return parsed.map(normalizeHit);
+      }
+    } catch {
+      // fall through to JSONL parsing
+    }
+
+    return parseJsonLines(stdout).map(normalizeHit);
+  } catch {
+    return [];
+  }
+}
+
+export async function qmdGet(options: {
+  qmdBin: string;
+  docId: string;
+  full?: boolean;
+}): Promise<string | null> {
+  const { qmdBin, docId, full } = options;
+
+  try {
+    const args = ["get", docId];
+    if (full) args.push("--full");
+
+    const { stdout } = await execFileAsync(qmdBin, args);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function qmdCollectionAdd(options: {
+  qmdBin: string;
+  name: string;
+  path: string;
+}): Promise<boolean> {
+  const { qmdBin, name, path } = options;
+
+  try {
+    await execFileAsync(qmdBin, ["collection", "add", path, "--name", name]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function qmdEmbed(options: {
+  qmdBin: string;
+  collection?: string;
+}): Promise<boolean> {
+  const { qmdBin, collection } = options;
+
+  try {
+    const args = ["embed"];
+    if (collection) args.push("-c", collection);
+    await execFileAsync(qmdBin, args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeHit(hit: any): MemoryHit {
+  return {
+    id: String(hit.id ?? hit.docId ?? hit.path ?? "unknown"),
+    score: typeof hit.score === "number" ? hit.score : undefined,
+    title: hit.title ?? hit.name,
+    snippet: hit.snippet ?? hit.text,
+    path: hit.path
+  };
+}

package/src/prompt.ts

@@ -0,0 +1,55 @@
+import os from "node:os";
+import { MemoryHit } from "./types.js";
+
+export function buildPrompt(options: {
+  identity: string;
+  personality: string;
+  memory: string;
+  hits: MemoryHit[];
+}) {
+  const { identity, personality, memory, hits } = options;
+  const hitText = hits
+    .map((hit, index) => {
+      const title = hit.title || hit.path || hit.id;
+      const snippet = hit.snippet || "";
+      return `(${index + 1}) ${title}\n${snippet}`.trim();
+    })
+    .filter(Boolean)
+    .join("\n\n");
+
+  const systemInfo = [
+    `platform: ${process.platform}`,
+    `arch: ${process.arch}`,
+    `cwd: ${process.cwd()}`,
+    `home: ${os.homedir()}`
+  ].join("\n");
+
+  const toolSpec = [
+    "Available tools:",
+    "- read: { path: string, maxBytes?: number }",
+    "- bash: { command: string, cwd?: string, timeoutMs?: number }",
+    "",
+    "Tool call rules:",
+    "1) Always include the tool name.",
+    "2) Always include required fields (read.path, bash.command).",
+    "3) Do not call tools with empty arguments.",
+    "4) Use bash for shell commands; do not invent other tool names.",
+  ].join("\n");
+
+  const sections = [
+    "# Identity\n" + identity.trim(),
+    "# Personality\n" + personality.trim(),
+    "# System Info\n" + systemInfo,
+    "# Tooling Policy\n" +
+      "You can use tools (read, bash) to answer questions. Prefer tools over asking the user to run commands. " +
+      "Only ask for clarification if needed to choose a safe tool or path.",
+    "# Tool Schemas\n" + toolSpec,
+    "# Long-term Memory\n" + memory.trim()
+  ];
+
+  if (hitText.length > 0) {
+    sections.push("# Retrieved Memory\n" + hitText);
+  }
+
+  return sections.join("\n\n").trim();
+}

package/src/session.ts

@@ -0,0 +1,35 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export type SessionFile = {
+  id: string;
+  path: string;
+};
+
+function formatDate(date: Date) {
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+
+export async function createSessionFile(sessionsDir: string, sessionId: string): Promise<SessionFile> {
+  const date = formatDate(new Date());
+  const fileName = `${date}-${sessionId}.md`;
+  const sessionPath = path.join(sessionsDir, fileName);
+
+  try {
+    await fs.access(sessionPath);
+  } catch {
+    const header = `# Session ${fileName}\n\n`;
+    await fs.writeFile(sessionPath, header, "utf8");
+  }
+
+  return { id: sessionId, path: sessionPath };
+}
+
+export async function appendSession(sessionPath: string, role: "user" | "assistant", content: string) {
+  const timestamp = new Date().toISOString();
+  const block = `## ${role} @ ${timestamp}\n\n${content}\n\n`;
+  await fs.appendFile(sessionPath, block, "utf8");
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+export type Role = "user" | "assistant" | "system" | "tool";
+
+export type Message = {
+  role: Role;
+  content: string;
+};
+
+export type MemoryHit = {
+  id: string;
+  score?: number;
+  title?: string;
+  snippet?: string;
+  path?: string;
+};
+
+export type AgentInput = {
+  prompt: string;
+  userMessage: string;
+};
+
+export type Agent = {
+  streamReply: (input: AgentInput) => AsyncGenerator<string>;
+  setModel?: (provider: string, modelId: string) => { ok: boolean; message: string };
+  getCurrentModel?: () => string | null;
+  onEvent?: (handler: (event: any) => void) => void;
+};
+
+export type AppConfig = {
+  workspacePath: string;
+  sessionId: string;
+  qmdBin: string;
+  qmdLimit: number;
+  qmdEnabled: boolean;
+  qmdCollection?: string;
+  qmdFull: boolean;
+  model?: string;
+  modelProvider?: string;
+  modelId?: string;
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+};

package/src/workspace.ts

@@ -0,0 +1,58 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_IDENTITY = "# Identity\n\nYou are Amiko, a helpful CLI agent.\n";
+const DEFAULT_PERSONALITY = "# Personality\n\n- Clear, concise, friendly.\n- Ask for clarification when unsure.\n";
+const DEFAULT_MEMORY = "# Memory\n\n";
+
+export type WorkspaceFiles = {
+  root: string;
+  identityPath: string;
+  personalityPath: string;
+  memoryPath: string;
+  sessionsDir: string;
+};
+
+async function ensureDir(dirPath: string) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function ensureFile(filePath: string, content: string) {
+  try {
+    await fs.access(filePath);
+  } catch {
+    await fs.writeFile(filePath, content, "utf8");
+  }
+}
+
+export async function initWorkspace(root: string): Promise<WorkspaceFiles> {
+  const identityPath = path.join(root, "IDENTITY.md");
+  const personalityPath = path.join(root, "PERSONALITY.md");
+  const memoryPath = path.join(root, "MEMORY.md");
+  const sessionsDir = path.join(root, "sessions");
+
+  await ensureDir(root);
+  await ensureDir(sessionsDir);
+
+  await ensureFile(identityPath, DEFAULT_IDENTITY);
+  await ensureFile(personalityPath, DEFAULT_PERSONALITY);
+  await ensureFile(memoryPath, DEFAULT_MEMORY);
+
+  return {
+    root,
+    identityPath,
+    personalityPath,
+    memoryPath,
+    sessionsDir
+  };
+}
+
+export async function readWorkspaceFiles(files: WorkspaceFiles) {
+  const [identity, personality, memory] = await Promise.all([
+    fs.readFile(files.identityPath, "utf8"),
+    fs.readFile(files.personalityPath, "utf8"),
+    fs.readFile(files.memoryPath, "utf8")
+  ]);
+
+  return { identity, personality, memory };
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/README.md

@@ -1,222 +0,0 @@
-# Amiko CLI
-
-Manage agents, wallets, credits, and the MPP marketplace from your terminal. Works for both human users and AI agents running on OpenClaw.
-
-## Install
-
-```bash
-npm install -g @heyamiko/amiko-cli
-# or
-bun install -g @heyamiko/amiko-cli
-```
-
-Update to latest:
-
-```bash
-amiko update
-```
-
-## Quick Start
-
-```bash
-# Connect your account
-amiko connect <CODE>              # paste code from Amiko settings
-amiko connect amk_<key>           # or use your API key directly
-amiko connect                     # or open browser to sign in
-
-# Check your balance
-amiko credits balance
-
-# Top up credits from your agent's wallet
-amiko credits topup 10000 --token AMIKO --yes
-
-# Swap tokens on Solana
-amiko swap send 1 amiko usdc
-
-# Browse and call marketplace agents
-amiko browse
-amiko call titan-research "Summarize the latest AI news"
-```
-
-## Connect
-
-Three ways to authenticate:
-
-```bash
-amiko connect <CODE>              # 7-char code from platform settings (recommended)
-amiko connect amk_<key>           # API key (shown once at creation)
-amiko connect                     # browser sign-in flow
-```
-
-The connect code is the simplest — generate one from your Amiko settings page, paste it to the agent or terminal. Connect auto-detects your Solana wallet for swaps.
-
-```bash
-amiko whoami                      # show current auth status
-amiko logout                      # clear stored credentials
-```
-
-## Credits
-
-```bash
-amiko credits balance             # credit balance + wallet balances across all chains
-amiko credits topup <amount>      # top up credits (amount in credits, e.g. 10000)
-```
-
-**Top-up options:**
-
-```bash
-amiko credits topup 10000                             # auto-select best wallet + token
-amiko credits topup 10000 --token AMIKO               # use AMIKO (Solana)
-amiko credits topup 10000 --token USDC --chain base   # use USDC on Base
-amiko credits topup 5000 --method mpp                 # use MPP 402 payment
-amiko credits topup 10000 --wallet Gu2b...QVya        # specific wallet address
-amiko credits topup 10000 --yes                       # skip confirmation
-```
-
-**How it works:**
-1. CLI fetches live token price from Jupiter
-2. Transfers tokens from your Crossmint agent wallet to the treasury via billing API
-3. Verifies the on-chain transfer and credits your account
-4. All calls go through `billing.heyamiko.com` — no other dependencies
-
-**Supported tokens:** AMIKO, SOL, USDC, USDT, ETH
-**Supported chains:** Solana, Base, Ethereum, Tempo
-
-## Wallet
-
-```bash
-amiko wallet create               # create MPP wallet on Tempo
-amiko wallet balance [address]    # check USDC.e balance
-amiko wallet balance --watch      # poll every 5s
-amiko wallet topup <amount>       # Stripe checkout ($1-$100)
-amiko wallet deposit [address]    # USDC.e deposit instructions
-amiko wallet login                # Tempo wallet login
-amiko wallet whoami               # Tempo wallet identity
-amiko wallet fund                 # fund via Tempo dashboard
-```
-
-## Marketplace
-
-```bash
-amiko browse                      # browse agents
-amiko browse -c research -l 10   # filter by category
-amiko info <agent>                # agent details + pricing
-amiko popular                     # trending agents
-amiko activity                    # recent payments
-amiko leaderboard                 # top creators
-```
-
-## Calling Agents
-
-```bash
-amiko call <agent> "message"      # single message
-amiko call <agent> -i             # interactive REPL
-echo "input" | amiko call <agent> # pipe input
-amiko call <agent> "msg" --task   # task endpoint
-amiko call <agent> "msg" --dry-run # preview cost
-```
-
-## Creator Dashboard
-
-```bash
-amiko creator summary             # earnings + listings
-amiko creator listings            # your agent listings
-amiko creator publish <id>        # publish a draft
-amiko creator payout              # request payout
-```
-
-## Swap (Solana)
-
-Swap tokens on Solana via Jupiter aggregator. Wallet auto-detected from your connected account — no setup needed.
-
-```bash
-amiko swap send 1 amiko usdc      # swap 1 AMIKO → USDC (auto-detect wallet)
-amiko swap send 5 usdt usdc --yes # skip confirmation
-amiko swap send 0.1 sol usdc      # SOL → USDC
-amiko swap quote 1 amiko usdc     # preview without executing
-amiko swap tokens                 # list supported tokens
-```
-
-Supports symbols (`sol`, `usdc`, `usdt`, `amiko`, `bonk`, `jup`, `pyusd`, `jitosol`, `ray`, `wbtc`) or raw mint addresses.
-
-Swaps execute via Crossmint smart wallets — your agent wallet signs and submits on-chain automatically. In non-interactive environments (agents), confirmation is auto-skipped — no `--yes` needed.
-
-## Bridge (Cross-Chain)
-
-Bridge tokens across 26+ chains via Across Protocol:
-
-```bash
-amiko bridge quote 10              # Solana → Tempo (default)
-amiko bridge quote 5 --from base --to tempo
-amiko bridge send 10 --from solana --to tempo --recipient 0x...
-amiko bridge routes                # list available routes
-amiko bridge limits                # check transfer limits
-amiko bridge status <txHash>       # track bridge status
-```
-
-## Other Commands
-
-```bash
-amiko reputation [address]        # TARS score
-amiko discover                    # MPP service info
-amiko ping                        # health check
-amiko config show                 # view config
-amiko config set <key> <value>    # set config value
-amiko update                      # update CLI to latest
-```
-
-## Agent Integration (OpenClaw)
-
-Agents install the CLI and connect with a code from the user:
-
-```bash
-npm install -g @heyamiko/amiko-cli
-amiko connect <CODE>
-amiko credits balance
-amiko credits topup 10000 --token AMIKO --yes
-amiko swap send 1 amiko usdc       # swap tokens on Solana
-```
-
-Connect auto-detects the agent's Solana wallet — no manual wallet setup needed. The CLI auto-detects `.amiko.json` (synced by the platform) when running on an agent.
-
-## Configuration
-
-Config: `~/.amiko/config.json`
-
-| Key | Default |
-|-----|---------|
-| `billingBase` | `https://billing.heyamiko.com` |
-| `apiBase` | `https://mpp.amikomarkets.com` |
-| `siteBase` | `https://platform.heyamiko.com` |
-
-## Architecture
-
-```
-src/
-├── index.ts              # entry point
-├── onboarding.ts         # first-run setup
-├── commands/
-│   ├── connect.ts        # connect (code, API key, browser)
-│   ├── credits.ts        # credits balance + topup
-│   ├── swap.ts           # Solana token swaps (Jupiter)
-│   ├── bridge.ts         # cross-chain bridging (Across)
-│   ├── browse.ts         # marketplace browsing
-│   ├── call.ts           # call agents
-│   ├── wallet.ts         # MPP wallet management
-│   ├── creator.ts        # creator dashboard
-│   ├── login.ts          # Privy browser login
-│   ├── update.ts         # self-update
-│   └── ...
-└── lib/
-    ├── config.ts          # ~/.amiko/config.json
-    ├── agent-config.ts    # .amiko.json reader
-    ├── api.ts             # HTTP client
-    ├── mpp-topup.ts       # MPP SDK helper
-    └── ...
-```
-
-Built with [Commander](https://github.com/tj/commander.js), [chalk](https://github.com/chalk/chalk), [ora](https://github.com/sindresorhus/ora), and [@solana/mpp](https://github.com/solana-foundation/mpp-sdk). Bundled with [Bun](https://bun.sh).
-
-## License
-
-MIT

package/dist/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node