@agtnames/cli 0.0.0-stage → 0.1.0

package/dist/widgets.js

@@ -0,0 +1,294 @@
+/**
+ * Prompt widgets. The placeholder rules (RATIONALE R-5, R-6):
+ *   prefill      a prediction from real data, dim after the cursor; Tab fills it, Enter submits. Typing over it never
+ *                loses it: it stays on the hint line, ↑ puts it back, ^Y copies it.
+ *   instruction  says what to enter; in the field when there is no prefill, otherwise on the label line. Always primary.
+ *   examples     only on an empty field after ~3 s idle, fading in italic below it; never fillable.
+ *
+ * Step navigation: `j` goes back a step and `;` skips it. In lists they are plain keys; in a typing field they act
+ * only while the field is empty, so a value containing j or ; types normally.
+ */
+import { BACK, copyToClipboard, SKIP, style } from "./tui.js";
+const PROMPT = "› ";
+const IDLE_MS = 3000;
+const FADE = [236, 238, 240, 242, 244];
+const printable = (str, key) => !!str && !key.ctrl && !key.meta && str.length >= 1 && !/[\x00-\x1f\x7f]/.test(str);
+export const NAV_HINT = "j back · ; skip";
+export class TextInput {
+    o;
+    value;
+    pos;
+    error = null;
+    flash = null;
+    lastKey = Date.now();
+    timer;
+    get label() { return this.o.label; }
+    constructor(o) {
+        this.o = o;
+        this.value = o.initial ?? "";
+        this.pos = this.value.length;
+    }
+    get prefill() { return this.o.prefill?.trim() || undefined; }
+    attach(redraw) {
+        // Repaint on a clock only for what changes by itself: the examples fade-in and flash messages.
+        this.timer = setInterval(() => {
+            const idle = Date.now() - this.lastKey;
+            const fading = !this.value && this.o.examples?.length && idle >= IDLE_MS && idle <= IDLE_MS + FADE.length * 150 + 300;
+            const cycling = !this.value && (this.o.examples?.length ?? 0) > 1 && idle > IDLE_MS;
+            const flashing = this.flash && Date.now() <= this.flash.until + 300;
+            if (fading || cycling || flashing)
+                redraw();
+        }, 150);
+    }
+    detach() { clearInterval(this.timer); }
+    say(text) { this.flash = { text, until: Date.now() + 1500 }; }
+    render() {
+        const p = this.prefill;
+        const width = Math.max(20, (process.stdout.columns ?? 80) - 1);
+        const lines = [];
+        const instructionInField = !this.value && !p;
+        lines.push(`${style.cyan("?")} ${style.bold(this.o.label)}${instructionInField ? "" : `  ${this.o.instruction}`}${this.o.optional ? style.dim(" (optional)") : ""}`);
+        // Field, windowed so the cursor stays visible on long values.
+        const room = width - PROMPT.length - 1;
+        let start = 0;
+        if (this.value.length > room)
+            start = Math.max(0, Math.min(this.pos - Math.floor(room * 0.7), this.value.length - room));
+        const shown = this.value.slice(start, start + room);
+        const clipped = start > 0 ? "…" + shown.slice(1) : shown;
+        let field;
+        if (instructionInField)
+            field = style.dim(this.o.instruction);
+        else if (!this.value && p)
+            field = style.dim(p);
+        else if (p && this.pos === this.value.length && p.length > this.value.length && p.toLowerCase().startsWith(this.value.toLowerCase()))
+            field = clipped + style.dim(p.slice(this.value.length));
+        else
+            field = clipped;
+        lines.push(PROMPT + field);
+        const cursorCol = PROMPT.length + (this.pos - start);
+        // Hint line: the suggestion is never lost.
+        if (p) {
+            const src = this.o.prefillSource ? style.dim(` (${this.o.prefillSource})`) : "";
+            if (!this.value)
+                lines.push(style.dim(`  Tab fills the suggestion · Enter submits · ^Y copies it${this.o.nav === false ? "" : " · " + NAV_HINT}`) + src);
+            else if (this.value !== p)
+                lines.push(style.dim("  suggested: ") + p + src + style.dim(" · ↑ restore · ^Y copy"));
+            else
+                lines.push(style.dim("  suggestion filled") + src + style.dim(" · ^K copy · Esc clear"));
+        }
+        const notes = [];
+        if (this.o.maxLength && this.value) {
+            const n = this.value.length;
+            const t = `${n}/${this.o.maxLength}`;
+            notes.push(n > this.o.maxLength ? style.red(t) : style.dim(t));
+        }
+        const note = this.o.note?.();
+        if (note)
+            notes.push(note);
+        if (this.flash && Date.now() <= this.flash.until)
+            notes.push(style.green(this.flash.text));
+        if (this.error)
+            notes.push(style.red(this.error));
+        if (!p && !this.value && this.o.nav !== false && !notes.length)
+            notes.push(style.dim(NAV_HINT));
+        if (notes.length)
+            lines.push("  " + notes.join(style.dim(" · ")));
+        // Examples: empty field, idle, fading in, italic, secondary.
+        const idle = Date.now() - this.lastKey;
+        if (!this.value && this.o.examples?.length && idle >= IDLE_MS) {
+            const step = Math.min(FADE.length - 1, Math.floor((idle - IDLE_MS) / 150));
+            const ex = this.o.examples[Math.floor((idle - IDLE_MS) / 5000) % this.o.examples.length];
+            lines.push(style.grey(FADE[step])(style.italic(`  e.g. ${ex}`)));
+        }
+        return { lines, cursor: { row: 1, col: cursorCol } };
+    }
+    onKey(str, key) {
+        this.lastKey = Date.now();
+        this.error = null;
+        const p = this.prefill;
+        if (!this.value && this.o.nav !== false && !key.ctrl && !key.meta) {
+            if (str === "j")
+                return { done: BACK };
+            if (str === ";")
+                return { done: SKIP };
+        }
+        const set = (v, pos = v.length) => { this.value = v; this.pos = pos; };
+        switch (key.name) {
+            case "return":
+            case "enter": {
+                const v = this.value.trim();
+                if (!v && !this.o.optional) {
+                    this.error = p ? "Tab fills the suggestion, or type your own" : "required";
+                    return;
+                }
+                const err = v ? this.o.validate?.(v) ?? null : null;
+                if (err) {
+                    this.error = err;
+                    return;
+                }
+                return { done: v };
+            }
+            case "tab":
+                if (p && this.value !== p)
+                    set(p);
+                return;
+            case "up":
+                if (p)
+                    set(p);
+                return;
+            case "escape":
+                set("");
+                return;
+            case "left":
+                this.pos = Math.max(0, this.pos - 1);
+                return;
+            case "right": {
+                if (this.pos === this.value.length && p && p.toLowerCase().startsWith(this.value.toLowerCase()) && p.length > this.value.length)
+                    set(this.value + p[this.value.length]);
+                else
+                    this.pos = Math.min(this.value.length, this.pos + 1);
+                return;
+            }
+            case "home":
+                this.pos = 0;
+                return;
+            case "end":
+                this.pos = this.value.length;
+                return;
+            case "backspace":
+                if (this.pos > 0)
+                    set(this.value.slice(0, this.pos - 1) + this.value.slice(this.pos), this.pos - 1);
+                return;
+            case "delete":
+                set(this.value.slice(0, this.pos) + this.value.slice(this.pos + 1), this.pos);
+                return;
+        }
+        if (key.ctrl) {
+            if (key.name === "a")
+                this.pos = 0;
+            else if (key.name === "e")
+                this.pos = this.value.length;
+            else if (key.name === "u")
+                set(this.value.slice(this.pos), 0);
+            else if (key.name === "w") {
+                const left = this.value.slice(0, this.pos).replace(/\S+\s*$/, "");
+                set(left + this.value.slice(this.pos), left.length);
+            }
+            else if (key.name === "y") {
+                const t = p ?? this.value;
+                if (t) {
+                    copyToClipboard(t);
+                    this.say(`copied: ${t.length > 40 ? t.slice(0, 40) + "…" : t}`);
+                }
+            }
+            else if (key.name === "k") {
+                if (this.value) {
+                    copyToClipboard(this.value);
+                    this.say("copied what you typed");
+                }
+            }
+            return;
+        }
+        if (printable(str, key))
+            set(this.value.slice(0, this.pos) + str.replace(/[\r\n]+/g, " ") + this.value.slice(this.pos), this.pos + str.length);
+    }
+    summary(v) {
+        return `${style.green("✔")} ${style.bold(this.o.label)} ${typeof v === "string" && v ? style.cyan(v) : style.dim("(empty)")}`;
+    }
+}
+export class Select {
+    o;
+    i;
+    get label() { return this.o.label; }
+    constructor(o) {
+        this.o = o;
+        const at = o.choices.findIndex((c) => c.value === o.initial);
+        this.i = at >= 0 ? at : 0;
+    }
+    render() {
+        const w = Math.max(...this.o.choices.map((c) => c.label.length));
+        const lines = [`${style.cyan("?")} ${style.bold(this.o.label)}  ${this.o.instruction}`];
+        this.o.choices.forEach((c, i) => {
+            const on = i === this.i;
+            const pre = on && this.o.initial === c.value && this.o.prefillSource ? style.dim(` (${this.o.prefillSource})`) : "";
+            lines.push(`${on ? style.cyan("❯ ◉") : "  ○"} ${on ? style.bold(c.label.padEnd(w)) : c.label.padEnd(w)}  ${style.dim(c.description ?? "")}${pre}`);
+        });
+        lines.push(style.dim(`  ↑/↓ or 1–9 to choose · Enter confirms · ${NAV_HINT}`));
+        return { lines, cursor: { row: 1 + this.i, col: 2 } };
+    }
+    onKey(str, key) {
+        const n = this.o.choices.length;
+        if (str === "j")
+            return { done: BACK };
+        if (str === ";")
+            return { done: SKIP };
+        if (key.name === "up")
+            this.i = (this.i - 1 + n) % n;
+        else if (key.name === "down")
+            this.i = (this.i + 1) % n;
+        else if (key.name === "return" || key.name === "enter")
+            return { done: this.o.choices[this.i].value };
+        else if (str && /^[1-9]$/.test(str) && Number(str) <= n)
+            this.i = Number(str) - 1;
+    }
+    summary(v) { return `${style.green("✔")} ${style.bold(this.o.label)} ${style.cyan(this.o.choices.find((c) => c.value === v)?.label ?? String(v))}`; }
+}
+// ── multiple choice ───────────────────────────────────────────────────────────────────────────────────────────────
+export class Checkbox {
+    o;
+    i = 0;
+    get label() { return this.o.label; }
+    on;
+    error = null;
+    constructor(o) {
+        this.o = o;
+        this.on = new Set(o.initial ?? []);
+    }
+    render() {
+        const w = Math.max(...this.o.choices.map((c) => c.label.length));
+        const lines = [`${style.cyan("?")} ${style.bold(this.o.label)}  ${this.o.instruction}`];
+        this.o.choices.forEach((c, i) => {
+            const box = this.on.has(c.value) ? style.green("◼") : "◻";
+            lines.push(`${i === this.i ? style.cyan("❯") : " "} ${box} ${i === this.i ? style.bold(c.label.padEnd(w)) : c.label.padEnd(w)}  ${style.dim(c.description ?? "")}`);
+        });
+        lines.push(this.error ? "  " + style.red(this.error) : style.dim(`  Space toggles · a all/none · Enter confirms · ${NAV_HINT}`));
+        return { lines, cursor: { row: 1 + this.i, col: 2 } };
+    }
+    onKey(str, key) {
+        this.error = null;
+        if (str === "j")
+            return { done: BACK };
+        if (str === ";")
+            return { done: SKIP };
+        const n = this.o.choices.length;
+        const cur = this.o.choices[this.i].value;
+        if (key.name === "up")
+            this.i = (this.i - 1 + n) % n;
+        else if (key.name === "down")
+            this.i = (this.i + 1) % n;
+        else if (key.name === "space" || str === " ") {
+            if (this.on.has(cur))
+                this.on.delete(cur);
+            else
+                this.on.add(cur);
+        }
+        else if (str === "a") {
+            if (this.on.size === n)
+                this.on.clear();
+            else
+                this.o.choices.forEach((c) => this.on.add(c.value));
+        }
+        else if (key.name === "return" || key.name === "enter") {
+            if (this.on.size < (this.o.min ?? 0)) {
+                this.error = `choose at least ${this.o.min}`;
+                return;
+            }
+            return { done: this.o.choices.filter((c) => this.on.has(c.value)).map((c) => c.value) };
+        }
+    }
+    summary(v) {
+        if (!Array.isArray(v))
+            return "";
+        return `${style.green("✔")} ${style.bold(this.o.label)} ${v.length ? style.cyan(this.o.choices.filter((c) => v.includes(c.value)).map((c) => c.label).join(", ")) : style.dim("(none)")}`;
+    }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@agtnames/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Register a .agt name, publish a signed manifest, set records and verify the result from a terminal. Signs in MetaMask through a local page, or with a key from the environment or an encrypted keyfile.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "agt": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/*.test.js",
+    "!dist/*.test.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agtnames/agt.git",
+    "directory": "packages/cli"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/*.test.js",
+    "prepublishOnly": "node scripts/check-publish-deps.mjs && npm run build && npm test"
+  },
+  "dependencies": {
+    "@agtnames/resolver": "^1.5.0",
+    "viem": "^2.56.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "agt",
+    "agent-identity",
+    "cli",
+    "metamask",
+    "manifest",
+    "agent",
+    "ai-agents",
+    "mcp",
+    "a2a",
+    "polygon",
+    "naming"
+  ],
+  "license": "MIT",
+  "homepage": "https://agtnames.com/docs/guides/command-line",
+  "bugs": {
+    "url": "https://github.com/agtnames/agt/issues"
+  }
+}