memopaper 1.0.0

package/README.md

@@ -0,0 +1,88 @@
+# memopaper
+
+CLI client for [memopaper](https://memopaper.dev) — store and retrieve memos from your terminal.
+
+## Installation
+
+```bash
+npm install -g memopaper
+```
+
+## Setup
+
+```bash
+memopaper init
+```
+
+Enter your API key when prompted. Get one at [memopaper.dev](https://memopaper.dev) under **Dashboard → API Keys**.
+
+Config is saved to `~/.memopaper/config.json`:
+
+```json
+{
+  "api_key": "mp_..."
+}
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `init` | Configure API key |
+| `add` | Save a memo |
+| `list` | List memos |
+| `get <uuid\|index>` | Get a memo by UUID or index (1=latest) |
+| `latest` | Get the latest memo |
+| `oldest` | Get the oldest memo |
+| `pop` | Get and delete the latest memo |
+| `delete <uuid\|index>` | Delete a memo |
+| `edit <uuid\|index> <text>` | Edit a memo's text |
+| `copy` | Copy the latest memo to clipboard |
+| `stats` | Show memo count by group |
+
+### `add`
+
+```bash
+memopaper add "text"                   # save to inbox
+memopaper add -g work "text"           # save to a group
+memopaper add --public "text"          # save as public
+memopaper add --file path/to/file.txt  # save file contents
+echo "text" | memopaper add            # pipe from stdin
+```
+
+### `list`
+
+```bash
+memopaper list              # list inbox
+memopaper list -g work      # list a group
+memopaper list -n 50        # show up to 50 memos
+```
+
+### `get`
+
+```bash
+memopaper get 1             # latest memo
+memopaper get 2 -g work     # 2nd latest in @work
+memopaper get <uuid>        # by UUID
+```
+
+### `pop`
+
+```bash
+memopaper pop               # read + delete latest from inbox
+memopaper pop -g work       # read + delete latest from @work
+```
+
+### `copy`
+
+```bash
+memopaper copy              # copy latest memo to clipboard
+memopaper copy -g work      # copy latest from @work
+```
+
+Supports macOS (`pbcopy`), Linux (`xclip`), and Windows (PowerShell).
+
+## Related
+
+- [memopaper.dev](https://memopaper.dev) — web dashboard
+- [memopaper-mcp](https://www.npmjs.com/package/memopaper-mcp) — MCP server for AI agents

package/dist/client.js

@@ -0,0 +1,95 @@
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertMemo(value) {
+    if (typeof value !== "object" || value === null ||
+        typeof value.id !== "string" ||
+        !UUID_REGEX.test(value.id) ||
+        typeof value.text !== "string" ||
+        typeof value.group !== "string") {
+        throw new Error("Unexpected response format from API");
+    }
+    return value;
+}
+export class MemoApiClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        let parsed;
+        try {
+            parsed = new URL(baseUrl);
+        }
+        catch {
+            throw new Error(`Invalid api_url: "${baseUrl}"`);
+        }
+        if (parsed.protocol !== "https:" && parsed.hostname !== "localhost" && parsed.hostname !== "127.0.0.1") {
+            process.stderr.write("WARNING: api_url is not HTTPS. API key will be sent in plaintext.\n");
+        }
+    }
+    async request(path, options) {
+        const res = await fetch(`${this.baseUrl}/api${path}`, {
+            ...options,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+                ...options?.headers,
+            },
+        });
+        if (res.status === 204)
+            return {};
+        const body = await res.json();
+        if (!res.ok) {
+            const raw = body?.error?.message ?? `API error: ${res.status}`;
+            const message = raw.length > 200 ? raw.slice(0, 200) + "…" : raw;
+            throw Object.assign(new Error(message), { code: body?.error?.code });
+        }
+        return body;
+    }
+    async create(data) {
+        const res = await this.request("/memos", {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+        return assertMemo(res);
+    }
+    async list(params = {}) {
+        const qs = new URLSearchParams();
+        if (params.group)
+            qs.set("group", params.group);
+        if (params.visibility)
+            qs.set("visibility", params.visibility);
+        if (params.limit)
+            qs.set("limit", String(params.limit));
+        if (params.offset)
+            qs.set("offset", String(params.offset));
+        if (params.order)
+            qs.set("order", params.order);
+        return this.request(`/memos?${qs}`);
+    }
+    async first(group) {
+        const result = await this.list({ group, limit: 1, order: "asc" });
+        return result.data[0] ?? null;
+    }
+    async get(uuid) {
+        const res = await this.request(`/memos/${encodeURIComponent(uuid)}`);
+        return assertMemo(res);
+    }
+    async pop(group) {
+        const qs = group ? `?group=${encodeURIComponent(group)}` : "";
+        const res = await this.request(`/memos/pop${qs}`, { method: "DELETE" });
+        return assertMemo(res);
+    }
+    async delete(uuid) {
+        await this.request(`/memos/${uuid}`, { method: "DELETE" });
+    }
+    async edit(uuid, text) {
+        const res = await this.request(`/memos/${encodeURIComponent(uuid)}`, {
+            method: "PUT",
+            body: JSON.stringify({ text }),
+        });
+        return assertMemo(res);
+    }
+    async stats() {
+        return this.request("/memos/stats");
+    }
+}

package/dist/commands/add.js

@@ -0,0 +1,110 @@
+import { fstatSync } from "fs";
+import { readConfig } from "../config.js";
+import { readFromFile, readFromStdin, validateInput, safeTruncate, promptConfirm } from "../input.js";
+import { MemoApiClient } from "../client.js";
+function isStdinInteractive() {
+    try {
+        return fstatSync(0).isCharacterDevice();
+    }
+    catch {
+        return process.stdin.isTTY ?? false;
+    }
+}
+export async function buildAddText({ text, file, stdinText, maxBytes }) {
+    if (file && text)
+        throw Object.assign(new Error("--file and text argument cannot be used together"), { code: "CONFLICTING_OPTIONS" });
+    if (file && stdinText)
+        throw Object.assign(new Error("stdin and --file cannot be used together"), { code: "CONFLICTING_OPTIONS" });
+    let content;
+    if (file) {
+        content = await readFromFile(file);
+    }
+    else if (stdinText !== null) {
+        content = stdinText;
+    }
+    else {
+        content = text ?? "";
+    }
+    const validation = validateInput(content, maxBytes);
+    if (validation.ok)
+        return validation.text;
+    const { bytes } = validation;
+    const confirmed = await promptConfirm(`Input is ${bytes} bytes (max ${maxBytes}). Truncate and save? [y/N] `);
+    if (!confirmed)
+        return null;
+    return safeTruncate(content, maxBytes);
+}
+export function registerAddCommand(program) {
+    program
+        .command("add [text]")
+        .description("Add a memo")
+        .option("--file <path>", "read content from file")
+        .option("-g, --group <group>", "group (default: inbox)")
+        .option("--public", "save as public memo")
+        .action(async (text, options) => {
+        const config = readConfig();
+        // stdin detection: skip stdin if --file or text arg is given, or if TTY
+        const stdinText = (options.file || text || isStdinInteractive()) ? null : await readFromStdin();
+        let content;
+        try {
+            content = await buildAddText({
+                text,
+                file: options.file,
+                stdinText,
+                maxBytes: config.max_bytes,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = err.code;
+            console.error(message);
+            if (code === "NOT_FOUND") {
+                process.exitCode = 3;
+                return;
+            }
+            if (code === "CONFLICTING_OPTIONS") {
+                process.exitCode = 4;
+                return;
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (content === null) {
+            process.exitCode = 0;
+            return;
+        }
+        if (!content.trim()) {
+            console.error("Memo content is empty");
+            process.exitCode = 4;
+            return;
+        }
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const memo = await client.create({
+                text: content,
+                group: options.group,
+                visibility: options.public ? "public" : "private",
+            });
+            console.log(`✓ saved [@${memo.group}] ${memo.id}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = err.code;
+            console.error(`Failed to save: ${message}`);
+            if (code === "UNAUTHORIZED") {
+                process.exitCode = 2;
+                return;
+            }
+            if (code === "MEMO_TOO_LONG" || code === "INVALID_GROUP" || code === "INVALID_VISIBILITY") {
+                process.exitCode = 4;
+                return;
+            }
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/copy.js

@@ -0,0 +1,64 @@
+import { spawn } from "child_process";
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+function copyToClipboard(text) {
+    return new Promise((resolve, reject) => {
+        let cmd;
+        let args;
+        if (process.platform === "win32") {
+            cmd = "powershell";
+            args = ["-noprofile", "-command", "[Console]::InputEncoding = [Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())"];
+        }
+        else if (process.platform === "darwin") {
+            cmd = "pbcopy";
+            args = [];
+        }
+        else {
+            cmd = "xclip";
+            args = ["-selection", "clipboard"];
+        }
+        const proc = spawn(cmd, args, { stdio: ["pipe", "inherit", "inherit"] });
+        proc.on("error", (err) => {
+            reject(new Error(`Clipboard command failed: ${err.message}`));
+        });
+        proc.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Clipboard copy failed (exit ${code})`));
+        });
+        proc.stdin.write(text, "utf8");
+        proc.stdin.end();
+    });
+}
+export function registerCopyCommand(program) {
+    program
+        .command("copy")
+        .description("Copy the latest memo to clipboard")
+        .option("-g, --group <group>", "group filter")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const result = await client.list({ limit: 1, group: options.group });
+            if (result.data.length === 0) {
+                console.error(options.group ? `No memos in @${options.group}` : "No memos");
+                process.exitCode = 1;
+                return;
+            }
+            const memo = result.data[0];
+            await copyToClipboard(memo.text);
+            console.log(`✓ copied to clipboard [@${memo.group}] ${memo.id}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to copy: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/delete.js

@@ -0,0 +1,33 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+import { resolveUuid } from "../resolve.js";
+export function registerDeleteCommand(program) {
+    program
+        .command("delete <uuid-or-index>")
+        .description("Delete a memo by UUID or 1-based index (1=latest)")
+        .option("-g, --group <group>", "group filter (used with index)")
+        .action(async (ref, options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const uuid = await resolveUuid(client, ref, options.group);
+            if (!uuid) {
+                console.error(`No memo at index ${ref}`);
+                process.exitCode = 1;
+                return;
+            }
+            await client.delete(uuid);
+            console.log(`✓ deleted (${uuid})`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to delete: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/edit.js

@@ -0,0 +1,33 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+import { resolveUuid } from "../resolve.js";
+export function registerEditCommand(program) {
+    program
+        .command("edit <uuid-or-index> <text>")
+        .description("Edit a memo's text by UUID or 1-based index (1=latest)")
+        .option("-g, --group <group>", "group filter (used with index)")
+        .action(async (ref, text, options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const uuid = await resolveUuid(client, ref, options.group);
+            if (!uuid) {
+                console.error(`No memo at index ${ref}`);
+                process.exitCode = 1;
+                return;
+            }
+            const memo = await client.edit(uuid, text);
+            console.log(`✓ updated [@${memo.group}] ${memo.id}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to edit: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/first.js

@@ -0,0 +1,31 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerFirstCommand(program) {
+    program
+        .command("first")
+        .description("가장 오래된 메모 조회")
+        .option("-g, --group <group>", "그룹 필터")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API 키가 설정되지 않았습니다. 'memopaper init'을 실행하세요.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const memo = await client.first(options.group);
+            if (!memo) {
+                console.error(options.group ? `@${options.group} 그룹에 메모가 없습니다` : "메모가 없습니다");
+                process.exitCode = 1;
+                return;
+            }
+            process.stdout.write(memo.text + "\n");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`조회 실패: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/get.js

@@ -0,0 +1,33 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+import { resolveUuid } from "../resolve.js";
+export function registerGetCommand(program) {
+    program
+        .command("get <uuid-or-index>")
+        .description("Get a memo by UUID or 1-based index (1=latest)")
+        .option("-g, --group <group>", "group filter (used with index)")
+        .action(async (ref, options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const uuid = await resolveUuid(client, ref, options.group);
+            if (!uuid) {
+                console.error(`No memo at index ${ref}`);
+                process.exitCode = 1;
+                return;
+            }
+            const memo = await client.get(uuid);
+            process.stdout.write(memo.text + "\n");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,38 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { readConfig, writeConfig, defaultConfig } from "../config.js";
+import { promptInput, promptConfirm } from "../input.js";
+const CONFIG_PATH = join(homedir(), ".memopaper", "config.json");
+export function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Configure API key")
+        .action(async () => {
+        if (existsSync(CONFIG_PATH)) {
+            const current = readConfig();
+            const masked = current.api_key
+                ? `mp_${"*".repeat(8)}...${current.api_key.slice(-4)}`
+                : "(not set)";
+            console.log(`Current API key: ${masked}`);
+            const overwrite = await promptConfirm("Overwrite? [y/N] ");
+            if (!overwrite) {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        const apiKey = await promptInput("API key: ");
+        if (!apiKey) {
+            console.error("API key cannot be empty.");
+            process.exitCode = 1;
+            return;
+        }
+        if (!apiKey.startsWith("mp_")) {
+            console.error("Invalid API key format. Expected: mp_...");
+            process.exitCode = 1;
+            return;
+        }
+        writeConfig({ ...defaultConfig, api_key: apiKey });
+        console.log(`✓ Config saved (${CONFIG_PATH})`);
+    });
+}

package/dist/commands/latest.js

@@ -0,0 +1,31 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerLatestCommand(program) {
+    program
+        .command("latest")
+        .description("Get the latest memo")
+        .option("-g, --group <group>", "group filter")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const result = await client.list({ group: options.group, limit: 1 });
+            if (!result.data[0]) {
+                console.error(options.group ? `No memos in @${options.group}` : "No memos");
+                process.exitCode = 1;
+                return;
+            }
+            process.stdout.write(result.data[0].text + "\n");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/list.js

@@ -0,0 +1,40 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerListCommand(program) {
+    program
+        .command("list")
+        .description("List memos")
+        .option("-g, --group <group>", "group filter")
+        .option("-n, --limit <number>", "max count (default: 20)", "20")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const result = await client.list({
+                group: options.group,
+                limit: parseInt(options.limit, 10),
+            });
+            if (result.data.length === 0) {
+                console.error(options.group ? `No memos in @${options.group}` : "No memos");
+                process.exitCode = 1;
+                return;
+            }
+            for (let i = 0; i < result.data.length; i++) {
+                const m = result.data[i];
+                const preview = m.text.length > 80 ? m.text.slice(0, 80) + "…" : m.text;
+                console.log(`${i + 1}. @${m.group}  ${preview}`);
+            }
+            console.log(`\n${result.data.length} / ${result.total} memos`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/oldest.js

@@ -0,0 +1,31 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerOldestCommand(program) {
+    program
+        .command("oldest")
+        .description("Get the oldest memo")
+        .option("-g, --group <group>", "group filter")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const memo = await client.first(options.group);
+            if (!memo) {
+                console.error(options.group ? `No memos in @${options.group}` : "No memos");
+                process.exitCode = 1;
+                return;
+            }
+            process.stdout.write(memo.text + "\n");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/pop.js

@@ -0,0 +1,26 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerPopCommand(program) {
+    program
+        .command("pop")
+        .description("Get and delete the latest memo")
+        .option("-g, --group <group>", "group filter")
+        .action(async (options) => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const memo = await client.pop(options.group);
+            process.stdout.write(memo.text + "\n");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to pop: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/stats.js

@@ -0,0 +1,28 @@
+import { readConfig } from "../config.js";
+import { MemoApiClient } from "../client.js";
+export function registerStatsCommand(program) {
+    program
+        .command("stats")
+        .description("Show memo count by group")
+        .action(async () => {
+        const config = readConfig();
+        if (!config.api_key) {
+            console.error("API key not configured. Run 'memopaper init'.");
+            process.exitCode = 1;
+            return;
+        }
+        const client = new MemoApiClient(config.api_url, config.api_key);
+        try {
+            const stats = await client.stats();
+            console.log(`Total: ${stats.total}`);
+            for (const { group, count } of stats.groups) {
+                console.log(`  @${group}: ${count}`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch stats: ${message}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/config.js

@@ -0,0 +1,40 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+const CONFIG_DIR = join(homedir(), ".memopaper");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+export const defaultConfig = {
+    api_url: "https://memopaper.dev",
+    api_key: "",
+    max_bytes: 2048,
+};
+export function readConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return { ...defaultConfig };
+    try {
+        const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        const merged = { ...defaultConfig, ...raw };
+        if (typeof merged.api_url !== "string")
+            merged.api_url = defaultConfig.api_url;
+        if (typeof merged.api_key !== "string")
+            merged.api_key = defaultConfig.api_key;
+        if (typeof merged.max_bytes !== "number" ||
+            !Number.isInteger(merged.max_bytes) ||
+            merged.max_bytes <= 0) {
+            merged.max_bytes = defaultConfig.max_bytes;
+        }
+        return merged;
+    }
+    catch {
+        return { ...defaultConfig };
+    }
+}
+export function writeConfig(config) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+    }
+    catch (error) {
+        throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { registerAddCommand } from "./commands/add.js";
+import { registerCopyCommand } from "./commands/copy.js";
+import { registerDeleteCommand } from "./commands/delete.js";
+import { registerEditCommand } from "./commands/edit.js";
+import { registerGetCommand } from "./commands/get.js";
+import { registerInitCommand } from "./commands/init.js";
+import { registerLatestCommand } from "./commands/latest.js";
+import { registerListCommand } from "./commands/list.js";
+import { registerOldestCommand } from "./commands/oldest.js";
+import { registerPopCommand } from "./commands/pop.js";
+import { registerStatsCommand } from "./commands/stats.js";
+program.name("memopaper").version("1.0.0");
+registerInitCommand(program);
+registerAddCommand(program);
+registerListCommand(program);
+registerGetCommand(program);
+registerPopCommand(program);
+registerDeleteCommand(program);
+registerEditCommand(program);
+registerLatestCommand(program);
+registerCopyCommand(program);
+registerOldestCommand(program);
+registerStatsCommand(program);
+program.parse();

package/dist/input.js

@@ -0,0 +1,70 @@
+import { readFileSync, statSync } from "fs";
+const MAX_FILE_SIZE = 1024 * 1024; // 1 MB
+import { createInterface } from "readline";
+export function countBytes(text) {
+    return Buffer.byteLength(text, "utf-8");
+}
+export function safeTruncate(text, maxBytes) {
+    const buf = Buffer.from(text, "utf-8");
+    if (buf.length <= maxBytes)
+        return text;
+    // Back up while buf[end] is a UTF-8 continuation byte (0x80–0xBF)
+    let end = maxBytes;
+    while (end > 0 && (buf[end] & 0xc0) === 0x80)
+        end--;
+    return buf.slice(0, end).toString("utf-8");
+}
+export function validateInput(text, maxBytes) {
+    const bytes = countBytes(text);
+    if (bytes <= maxBytes)
+        return { ok: true, text };
+    return { ok: false, bytes, maxBytes };
+}
+export async function readFromFile(filePath) {
+    try {
+        const stat = statSync(filePath);
+        if (stat.size > MAX_FILE_SIZE) {
+            throw Object.assign(new Error(`File too large: ${stat.size} bytes (max ${MAX_FILE_SIZE})`), { code: "FILE_TOO_LARGE" });
+        }
+        return readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            throw Object.assign(new Error(`File not found: ${filePath}`), { code: "NOT_FOUND" });
+        }
+        if (code === "FILE_TOO_LARGE")
+            throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw Object.assign(new Error(`Failed to read file: ${message}`), { code: "READ_ERROR" });
+    }
+}
+export async function readFromStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const rl = createInterface({ input: process.stdin });
+        rl.on("line", (line) => chunks.push(line));
+        rl.on("close", () => resolve(chunks.join("\n")));
+        rl.on("error", (error) => reject(error));
+    });
+}
+export async function promptConfirm(question) {
+    return new Promise((resolve, reject) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.on("error", (error) => reject(error));
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y");
+        });
+    });
+}
+export async function promptInput(question) {
+    return new Promise((resolve, reject) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.on("error", (error) => reject(error));
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}

package/dist/resolve.js

@@ -0,0 +1,19 @@
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Resolves a UUID or 1-based index to a UUID.
+ * Returns null if the index is out of range.
+ * Throws if ref is neither a valid index nor a valid UUID.
+ */
+export async function resolveUuid(client, ref, group) {
+    if (/^\d+$/.test(ref)) {
+        const index = parseInt(ref, 10);
+        if (index < 1)
+            return null;
+        const result = await client.list({ group, limit: 1, offset: index - 1 });
+        return result.data[0]?.id ?? null;
+    }
+    if (!UUID_REGEX.test(ref)) {
+        throw new Error(`Invalid memo reference: expected a number or UUID, got "${ref}"`);
+    }
+    return ref;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "memopaper",
+  "version": "1.0.0",
+  "description": "CLI-first cross-device memo buffer for developers and agents",
+  "type": "module",
+  "bin": {
+    "memopaper": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agcraft/memopaper.git",
+    "directory": "memopaper-cli"
+  },
+  "homepage": "https://memopaper.dev",
+  "keywords": [
+    "memo",
+    "cli",
+    "terminal",
+    "cross-device",
+    "mcp",
+    "developer-tools"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsx": "^4.7.0",
+    "vitest": "^1.4.0",
+    "@types/node": "^20.0.0"
+  }
+}