@nothingmail/nmp 0.1.0

package/dist/api/index.d.ts

@@ -0,0 +1,238 @@
+import { p as NmpChannelConfig, y as NmpType, x as NmpStatus, v as NmpPriority, r as NmpContext, w as NmpSource, s as NmpError, z as TokenPermission } from '../types-BBAct0Gd.js';
+
+/** POST /api/messages/send */
+interface SendRequest {
+    to: string;
+    text: string;
+    subject?: string;
+    type?: NmpType;
+    project?: string;
+    labels?: string[];
+    priority?: NmpPriority;
+    files?: string[];
+    require?: string[];
+    reply_schema?: Record<string, unknown>;
+    ack?: boolean;
+}
+interface SendResponse {
+    success: boolean;
+    message_id: string;
+    status: NmpStatus;
+}
+/** GET /api/messages/inbox */
+interface InboxQuery {
+    unread?: boolean;
+    project?: string;
+    label?: string;
+    limit?: number;
+    offset?: number;
+}
+interface InboxResponse {
+    messages: MessageSummary[];
+    total_unread: number;
+}
+/** GET /api/messages/sent */
+interface SentQuery {
+    project?: string;
+    limit?: number;
+    offset?: number;
+}
+interface SentResponse {
+    messages: MessageSummary[];
+}
+/** GET /api/messages/:id */
+interface MessageDetail {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    date: string;
+    type: NmpType;
+    content: string;
+    project?: string;
+    labels?: string[];
+    priority?: NmpPriority;
+    context?: NmpContext;
+    channel?: ChannelRef;
+    status?: NmpStatus;
+    source?: NmpSource;
+    error?: NmpError;
+    attachments?: AttachmentInfo[];
+    thread?: ThreadMessage[];
+}
+/** POST /api/messages/:id/reply */
+interface ReplyRequest {
+    text: string;
+    files?: string[];
+}
+interface ReplyResponse {
+    success: boolean;
+    message_id: string;
+    status: NmpStatus;
+}
+/** GET /api/projects */
+interface ProjectInfo {
+    name: string;
+    total: number;
+    unread: number;
+    last_activity: string;
+}
+interface ProjectsResponse {
+    projects: ProjectInfo[];
+}
+/** Shared types */
+interface MessageSummary {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    preview: string;
+    date: string;
+    type: NmpType;
+    channel?: ChannelRef;
+    status?: NmpStatus;
+    unread?: boolean;
+    has_attachments: boolean;
+    project?: string;
+    labels?: string[];
+    thread_count?: number;
+}
+/** Channel reference in message responses (lightweight, not full config) */
+interface ChannelRef {
+    id: string;
+    name: string;
+    email: string;
+}
+interface AttachmentInfo {
+    filename: string;
+    size: number;
+    url: string;
+}
+interface ThreadMessage {
+    id: string;
+    from: string;
+    preview: string;
+    date: string;
+}
+/** GET /api/channels */
+interface ChannelsResponse {
+    channels: ChannelInfo[];
+}
+interface ChannelInfo {
+    id: string;
+    name: string;
+    type: NmpChannelConfig['type'];
+    email: string;
+    is_primary: boolean;
+    is_active: boolean;
+    created_at: string;
+}
+/** POST /api/channels */
+interface CreateChannelRequest {
+    name: string;
+    type: NmpChannelConfig['type'];
+    email: string;
+    smtp_host?: string;
+    smtp_port?: number;
+    imap_host?: string;
+    imap_port?: number;
+    password?: string;
+    is_primary?: boolean;
+}
+/** POST /api/channels/:id/test */
+interface TestChannelResponse {
+    smtp: boolean;
+    imap: boolean;
+}
+/** GET /api/reports */
+interface ReportQuery {
+    period?: 'today' | 'week' | 'month';
+    project?: string;
+}
+interface ReportResponse {
+    period: {
+        start: string;
+        end: string;
+        label: string;
+    };
+    summary: {
+        sent: number;
+        received: number;
+        replied: number;
+        failed: number;
+    };
+    projects: {
+        name: string;
+        messages: number;
+        threads: number;
+        resolved: number;
+    }[];
+    needs_reply: {
+        id: string;
+        from: string;
+        subject: string;
+        date: string;
+        project?: string;
+    }[];
+    top_threads: {
+        thread_id: string;
+        subject: string;
+        message_count: number;
+        status: string;
+        last_activity: string;
+    }[];
+}
+
+/** Account and token types for Nothing API */
+/** GET /api/account */
+interface AccountInfo {
+    id: string;
+    handle: string;
+    email: string;
+    display_name?: string;
+    github_username: string;
+    created_at: string;
+}
+/** GET /api/account/usage */
+interface UsageInfo {
+    messages_today: number;
+    messages_limit: number;
+    storage_used: number;
+    storage_limit: number;
+    tokens_count: number;
+    tokens_limit: number;
+}
+/** GET /api/account/tokens */
+interface TokenInfo {
+    id: string;
+    name: string;
+    token_preview: string;
+    permissions: TokenPermission[];
+    last_used?: string;
+    expires_at?: string;
+    created_at: string;
+    revoked: boolean;
+}
+/** POST /api/account/tokens */
+interface CreateTokenRequest {
+    name: string;
+    permissions: TokenPermission[];
+    expires_at?: string;
+}
+interface CreateTokenResponse {
+    id: string;
+    token: string;
+    name: string;
+    permissions: TokenPermission[];
+}
+/** POST /api/account/register */
+interface RegisterRequest {
+    handle: string;
+}
+interface RegisterResponse {
+    handle: string;
+    email: string;
+    master_token: string;
+}
+
+export { type AccountInfo, type AttachmentInfo, type ChannelInfo, type ChannelRef, type ChannelsResponse, type CreateChannelRequest, type CreateTokenRequest, type CreateTokenResponse, type InboxQuery, type InboxResponse, type MessageDetail, type MessageSummary, type ProjectInfo, type ProjectsResponse, type RegisterRequest, type RegisterResponse, type ReplyRequest, type ReplyResponse, type ReportQuery, type ReportResponse, type SendRequest, type SendResponse, type SentQuery, type SentResponse, type TestChannelResponse, type ThreadMessage, type TokenInfo, TokenPermission, type UsageInfo };

package/dist/index.d.ts

@@ -0,0 +1,224 @@
+import { N as NmpPayload, a as NmpMarkdown, b as NmpComplianceLevel } from './types-BBAct0Gd.js';
+export { c as NMP_ATTACHMENT_NAME, d as NMP_CHANNEL_TYPES, e as NMP_COMPLIANCE, f as NMP_DEFAULTS, g as NMP_ERROR_CODES, h as NMP_HEADERS, i as NMP_LIMITS, j as NMP_PRIORITIES, k as NMP_SOURCES, l as NMP_STATUSES, m as NMP_TYPES, n as NMP_VERSION, o as NmpAttachment, p as NmpChannelConfig, q as NmpChannelType, r as NmpContext, s as NmpError, t as NmpErrorCode, u as NmpMessage, v as NmpPriority, w as NmpSource, x as NmpStatus, y as NmpType, T as TOKEN_PERMISSIONS, z as TokenPermission } from './types-BBAct0Gd.js';
+
+/** Generic registry for extensible collections */
+declare class Registry<T> {
+    private items;
+    register(key: string, value: T): void;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    values(): T[];
+    entries(): [string, T][];
+    unregister(key: string): boolean;
+    get size(): number;
+}
+
+/** Generate nmp.md content from payload + message body */
+declare function generateMarkdown(content: string, payload: NmpPayload): string;
+/** Generate plain text (Part 1) from content + payload */
+declare function generatePlainText(content: string, payload: NmpPayload): string;
+/** Parse nmp.md content into structured data */
+declare function parseMarkdown(md: string): NmpMarkdown | null;
+
+/** Schema registry — extensible collection of Reply Schemas */
+declare const schemaRegistry: Registry<Record<string, unknown>>;
+/** Resolve a schema reference (e.g., "nmp:code-review") */
+declare function resolveSchema(ref: string): Record<string, unknown> | null;
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    level: NmpComplianceLevel;
+}
+/** Validate an NMP JSON payload */
+declare function validatePayload(payload: unknown): ValidationResult;
+/** Validate nmp.md content string */
+declare function validateMarkdown(md: string): ValidationResult;
+
+/** MCP tool definitions for Nothing — rich descriptions for Agent understanding */
+declare const NMP_TOOLS: {
+    readonly nothing_send: {
+        readonly name: "nothing_send";
+        readonly description: "Send an email or NMP message. Use when the user wants to notify someone, share code, ask a question, or delegate a task. Supports file attachments and project tagging. Example triggers: \"send this to bob\", \"email alice about the bug\", \"notify the team\".";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly to: {
+                    readonly type: "string";
+                    readonly description: "Recipient email address (e.g., bob@nothing.email, alice@gmail.com)";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Message body. For code discussions, include file paths and line numbers.";
+                };
+                readonly agent: {
+                    readonly type: "string";
+                    readonly description: "Your agent identity (e.g., \"claude-code\", \"cursor\"). Auto-detected from MCP context.";
+                };
+                readonly subject: {
+                    readonly type: "string";
+                    readonly description: "Subject line. Auto-generated from first 50 chars if omitted.";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["share", "question", "reply", "notify"];
+                    readonly description: "Message intent: share (FYI), question (expects reply), reply, notify (no reply expected)";
+                };
+                readonly project: {
+                    readonly type: "string";
+                    readonly description: "Project name for grouping (e.g., \"backend-refactor\"). Messages with same project are grouped together.";
+                };
+                readonly labels: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Tags for categorization (e.g., [\"code-review\", \"urgent\"])";
+                };
+                readonly files: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Absolute file paths to attach (e.g., [\"/path/to/file.ts\"])";
+                };
+                readonly require: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Capabilities the recipient must have (e.g., [\"code-review\"]). Recipient can reject if they lack the capability.";
+                };
+                readonly priority: {
+                    readonly type: "string";
+                    readonly enum: readonly ["urgent", "normal", "low"];
+                    readonly description: "Urgency level. Use \"urgent\" sparingly.";
+                };
+            };
+            readonly required: readonly ["to", "text"];
+        };
+    };
+    readonly nothing_inbox: {
+        readonly name: "nothing_inbox";
+        readonly description: "Check inbox for received messages. Use when the user asks \"any new messages?\", \"check my mail\", \"what did bob send?\", or \"show messages from gmail\". Supports filtering by channel (gmail/qq/nothing), sender, project, and labels.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly unread: {
+                    readonly type: "boolean";
+                    readonly description: "Only unread messages (default: true). Set false to see all.";
+                };
+                readonly project: {
+                    readonly type: "string";
+                    readonly description: "Filter by project name";
+                };
+                readonly label: {
+                    readonly type: "string";
+                    readonly description: "Filter by label";
+                };
+                readonly channel: {
+                    readonly type: "string";
+                    readonly description: "Filter by email channel: gmail, qq, outlook, nothing, local";
+                };
+                readonly source: {
+                    readonly type: "string";
+                    readonly enum: readonly ["nmp", "external"];
+                    readonly description: "Filter by message type: \"nmp\" for Agent messages, \"external\" for regular emails";
+                };
+                readonly agent: {
+                    readonly type: "string";
+                    readonly description: "Filter by sending agent name (exact match, e.g., \"claude-code\", \"cursor\", \"codex\")";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max messages to return (default: 20)";
+                };
+            };
+        };
+    };
+    readonly nothing_sent: {
+        readonly name: "nothing_sent";
+        readonly description: "Check sent messages and their delivery status. Use when the user asks \"did my message arrive?\", \"delivery status\", or \"what did I send?\". Shows 6 statuses: queued → sent → delivered → read → replied / failed.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max messages to return (default: 20)";
+                };
+                readonly project: {
+                    readonly type: "string";
+                    readonly description: "Filter by project";
+                };
+            };
+        };
+    };
+    readonly nothing_read: {
+        readonly name: "nothing_read";
+        readonly description: "Read a specific message in full. Use when the user says \"open that message\", \"read it\", \"show me the details\". Returns complete content, code context, attachments, and thread history. Marks message as read.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Message ID (from inbox or sent listing)";
+                };
+            };
+            readonly required: readonly ["id"];
+        };
+    };
+    readonly nothing_reply: {
+        readonly name: "nothing_reply";
+        readonly description: "Reply to a message within its thread. Use when the user says \"reply to that\", \"tell them yes\", \"respond with...\". Automatically inherits project, labels, and thread context from the original message.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Message ID to reply to";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Reply body";
+                };
+                readonly files: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "File paths to attach";
+                };
+            };
+            readonly required: readonly ["id", "text"];
+        };
+    };
+    readonly nothing_projects: {
+        readonly name: "nothing_projects";
+        readonly description: "List all projects with message counts and unread status. Use when the user asks \"what projects do I have?\", \"project overview\", or \"which projects have unread messages?\".";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly nothing_report: {
+        readonly name: "nothing_report";
+        readonly description: "Generate an activity report showing messages sent/received, project breakdown, items needing reply, and top threads. Use when the user asks \"weekly summary\", \"what happened this week?\", \"give me a report\", or \"any messages I missed?\".";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly period: {
+                    readonly type: "string";
+                    readonly enum: readonly ["today", "week", "month"];
+                    readonly description: "Time period (default: week)";
+                };
+                readonly project: {
+                    readonly type: "string";
+                    readonly description: "Filter report to a specific project";
+                };
+            };
+        };
+    };
+};
+
+export { NMP_TOOLS, NmpComplianceLevel, NmpMarkdown, NmpPayload, Registry, type ValidationResult, generateMarkdown, generatePlainText, parseMarkdown, resolveSchema, schemaRegistry, validateMarkdown, validatePayload };

package/dist/index.js

@@ -0,0 +1,419 @@
+// src/types.ts
+var NMP_VERSION = 1;
+var NMP_TYPES = ["share", "question", "reply", "notify"];
+var NMP_PRIORITIES = ["urgent", "normal", "low"];
+var NMP_STATUSES = ["queued", "sent", "delivered", "read", "replied", "failed"];
+var NMP_SOURCES = ["nmp", "external"];
+var NMP_CHANNEL_TYPES = ["nothing", "smtp", "stalwart", "local"];
+var TOKEN_PERMISSIONS = ["send", "inbox", "read", "reply", "manage"];
+var NMP_ERROR_CODES = [
+  "capability_not_supported",
+  "schema_mismatch",
+  "rate_limited",
+  "rejected",
+  "expired",
+  "version_unsupported",
+  "payload_too_large"
+];
+var NMP_COMPLIANCE = {
+  NONE: 0,
+  BASIC: 1,
+  FULL: 2
+};
+var NMP_DEFAULTS = {
+  subjectMaxLength: 50,
+  messageLimit: 20,
+  dailyMessageLimit: 50,
+  tokenRateLimit: 10,
+  priority: "normal",
+  type: "share"
+};
+var NMP_LIMITS = {
+  maxEmailSize: 10 * 1024 * 1024,
+  maxAttachments: 5,
+  maxJsonSize: 256 * 1024,
+  maxMarkdownSize: 64 * 1024,
+  maxPlainTextSize: 64 * 1024
+};
+var NMP_HEADERS = {
+  version: "X-NMP-Version",
+  type: "X-NMP-Type",
+  agent: "X-NMP-Agent",
+  project: "X-NMP-Project",
+  labels: "X-NMP-Labels",
+  priority: "X-NMP-Priority",
+  expires: "X-NMP-Expires",
+  capabilities: "X-NMP-Capabilities",
+  require: "X-NMP-Require",
+  replySchema: "X-NMP-Reply-Schema",
+  signature: "X-NMP-Signature"
+};
+var NMP_ATTACHMENT_NAME = "nmp.md";
+
+// src/registry.ts
+var Registry = class {
+  items = /* @__PURE__ */ new Map();
+  register(key, value) {
+    this.items.set(key, value);
+  }
+  get(key) {
+    return this.items.get(key);
+  }
+  has(key) {
+    return this.items.has(key);
+  }
+  keys() {
+    return [...this.items.keys()];
+  }
+  values() {
+    return [...this.items.values()];
+  }
+  entries() {
+    return [...this.items.entries()];
+  }
+  unregister(key) {
+    return this.items.delete(key);
+  }
+  get size() {
+    return this.items.size;
+  }
+};
+
+// src/markdown.ts
+function generateMarkdown(content, payload) {
+  const sections = [];
+  const messageParts = [];
+  messageParts.push(`- type: ${payload.type}`);
+  if (payload.agent) messageParts.push(`- agent: ${payload.agent}`);
+  if (payload.project) messageParts.push(`- project: ${payload.project}`);
+  if (payload.labels?.length) messageParts.push(`- labels: ${payload.labels.join(", ")}`);
+  if (payload.priority && payload.priority !== "normal") messageParts.push(`- priority: ${payload.priority}`);
+  if (payload.expires) messageParts.push(`- expires: ${payload.expires}`);
+  sections.push(`## Message
+
+${messageParts.join("\n")}`);
+  sections.push(`## Content
+
+${content}`);
+  if (payload.context) {
+    const ctx = payload.context;
+    const ctxParts = [];
+    if (ctx.repo) ctxParts.push(`- repo: ${ctx.repo}`);
+    if (ctx.file) ctxParts.push(`- file: ${ctx.file}`);
+    if (ctx.lines) ctxParts.push(`- lines: ${ctx.lines}`);
+    if (ctx.language) ctxParts.push(`- language: ${ctx.language}`);
+    if (ctxParts.length) sections.push(`## Context
+
+${ctxParts.join("\n")}`);
+  }
+  if (payload.capabilities?.length || payload.require?.length) {
+    const capParts = [];
+    if (payload.capabilities?.length) capParts.push(`- has: ${payload.capabilities.join(", ")}`);
+    if (payload.require?.length) capParts.push(`- require: ${payload.require.join(", ")}`);
+    sections.push(`## Capabilities
+
+${capParts.join("\n")}`);
+  }
+  if (payload.files?.length) {
+    const fileParts = payload.files.map((f) => `- ${f}`);
+    sections.push(`## Attachments
+
+${fileParts.join("\n")}`);
+  }
+  if (payload.reply_schema) {
+    const schemaLines = generateSchemaMarkdown(payload.reply_schema);
+    if (schemaLines.length) sections.push(`## Reply Schema
+
+${schemaLines.join("\n")}`);
+  }
+  return sections.join("\n\n") + "\n";
+}
+function generatePlainText(content, payload) {
+  const parts = [content];
+  const meta = [];
+  if (payload.context?.file) meta.push(`\u6587\u4EF6: ${payload.context.file}`);
+  if (payload.context?.lines) meta.push(`\u884C\u53F7: ${payload.context.lines}`);
+  if (payload.context?.repo) meta.push(`\u4ED3\u5E93: ${payload.context.repo}`);
+  if (payload.project) meta.push(`\u9879\u76EE: ${payload.project}`);
+  if (meta.length) {
+    parts.push("---");
+    parts.push(meta.join("\n"));
+  }
+  return parts.join("\n\n") + "\n";
+}
+function parseMarkdown(md) {
+  const sections = parseSections(md);
+  if (!sections["Message"] || !sections["Content"]) return null;
+  const message = parseKV(sections["Message"]);
+  const context = sections["Context"] ? parseContextKV(sections["Context"]) : void 0;
+  const capabilities = sections["Capabilities"] ? parseKV(sections["Capabilities"]) : void 0;
+  return {
+    type: message["type"] || "share",
+    agent: message["agent"],
+    project: message["project"],
+    labels: message["labels"]?.split(",").map((l) => l.trim()),
+    priority: message["priority"],
+    expires: message["expires"],
+    content: sections["Content"].trim(),
+    context,
+    capabilities: capabilities?.["has"]?.split(",").map((c) => c.trim()),
+    require: capabilities?.["require"]?.split(",").map((c) => c.trim()),
+    attachments: sections["Attachments"] ? sections["Attachments"].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2).trim()) : void 0,
+    replySchema: sections["Reply Schema"] ? sections["Reply Schema"].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2).trim()) : void 0
+  };
+}
+function parseSections(md) {
+  const sections = {};
+  const lines = md.split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const heading = line.match(/^## (.+)$/);
+    if (heading) {
+      currentSection = heading[1].trim();
+      sections[currentSection] = "";
+    } else if (currentSection) {
+      sections[currentSection] += line + "\n";
+    }
+  }
+  return sections;
+}
+function parseKV(text) {
+  const result = {};
+  for (const line of text.split("\n")) {
+    const match = line.match(/^- (\w[\w\s]*?):\s*(.+)$/);
+    if (match) result[match[1].trim()] = match[2].trim();
+  }
+  return result;
+}
+function parseContextKV(text) {
+  const kv = parseKV(text);
+  return {
+    repo: kv["repo"],
+    file: kv["file"],
+    lines: kv["lines"],
+    language: kv["language"]
+  };
+}
+function generateSchemaMarkdown(schema) {
+  const props = schema["properties"];
+  const required = schema["required"] || [];
+  if (!props) return [];
+  return Object.entries(props).map(([key, def]) => {
+    const type = def["enum"] ? def["enum"].join(" | ") : def["type"] || "string";
+    const desc = def["description"] ? ` (${def["description"]})` : "";
+    const req = required.includes(key) ? " [\u5FC5\u586B]" : "";
+    return `- ${key}: ${type}${desc}${req}`;
+  });
+}
+
+// src/schemas.ts
+var schemaRegistry = new Registry();
+var RISK_LEVELS = ["low", "medium", "high"];
+var SEVERITY_LEVELS = ["low", "medium", "high", "critical"];
+schemaRegistry.register("nmp:code-review", {
+  type: "object",
+  properties: {
+    approved: { type: "boolean", description: "Approve merge" },
+    risk_level: { type: "string", enum: [...RISK_LEVELS], description: "Risk level" },
+    comments: { type: "string", description: "Review comments" },
+    suggestions: { type: "string", description: "Improvement suggestions" }
+  },
+  required: ["approved", "risk_level", "comments"]
+});
+schemaRegistry.register("nmp:approval", {
+  type: "object",
+  properties: {
+    approved: { type: "boolean", description: "Approved" },
+    reason: { type: "string", description: "Reason" }
+  },
+  required: ["approved", "reason"]
+});
+schemaRegistry.register("nmp:bug-report", {
+  type: "object",
+  properties: {
+    severity: { type: "string", enum: [...SEVERITY_LEVELS], description: "Severity" },
+    steps: { type: "string", description: "Steps to reproduce" },
+    expected: { type: "string", description: "Expected behavior" },
+    actual: { type: "string", description: "Actual behavior" }
+  },
+  required: ["severity", "steps", "expected", "actual"]
+});
+schemaRegistry.register("nmp:translation", {
+  type: "object",
+  properties: {
+    translated_text: { type: "string", description: "Translated text" },
+    source_language: { type: "string", description: "Source language" },
+    target_language: { type: "string", description: "Target language" }
+  },
+  required: ["translated_text", "source_language", "target_language"]
+});
+function resolveSchema(ref) {
+  return schemaRegistry.get(ref) ?? null;
+}
+
+// src/validate.ts
+function validatePayload(payload) {
+  const errors = [];
+  if (!payload || typeof payload !== "object") {
+    return { valid: false, errors: ["Payload is not an object"], level: NMP_COMPLIANCE.NONE };
+  }
+  const p = payload;
+  if (p["nmp"] !== NMP_VERSION) {
+    errors.push(`Invalid nmp version: ${p["nmp"]}, expected ${NMP_VERSION}`);
+  }
+  if (!p["type"] || !NMP_TYPES.includes(p["type"])) {
+    errors.push(`Invalid type: ${p["type"]}, expected one of ${NMP_TYPES.join(", ")}`);
+  }
+  if (p["priority"] && !NMP_PRIORITIES.includes(p["priority"])) {
+    errors.push(`Invalid priority: ${p["priority"]}, expected one of ${NMP_PRIORITIES.join(", ")}`);
+  }
+  if (p["expires"] && isNaN(Date.parse(p["expires"]))) {
+    errors.push(`Invalid expires: ${p["expires"]}, expected ISO 8601 date`);
+  }
+  if (p["labels"] && !Array.isArray(p["labels"])) {
+    errors.push("labels must be a string array");
+  }
+  if (p["files"] && !Array.isArray(p["files"])) {
+    errors.push("files must be a string array");
+  }
+  let level = NMP_COMPLIANCE.NONE;
+  if (errors.length === 0) {
+    level = NMP_COMPLIANCE.BASIC;
+    if (p["capabilities"] || p["require"] || p["reply_schema"]) {
+      level = NMP_COMPLIANCE.FULL;
+    }
+  }
+  return { valid: errors.length === 0, errors, level };
+}
+function validateMarkdown(md) {
+  const errors = [];
+  if (md.length > NMP_LIMITS.maxMarkdownSize) {
+    errors.push(`Markdown exceeds ${NMP_LIMITS.maxMarkdownSize} bytes limit`);
+  }
+  if (!md.includes("## Message")) {
+    errors.push("Missing required ## Message section");
+  }
+  if (!md.includes("## Content")) {
+    errors.push("Missing required ## Content section");
+  }
+  const level = errors.length === 0 ? md.includes("## Capabilities") || md.includes("## Reply Schema") ? NMP_COMPLIANCE.FULL : NMP_COMPLIANCE.BASIC : NMP_COMPLIANCE.NONE;
+  return { valid: errors.length === 0, errors, level };
+}
+
+// src/tools.ts
+var NMP_TOOLS = {
+  nothing_send: {
+    name: "nothing_send",
+    description: 'Send an email or NMP message. Use when the user wants to notify someone, share code, ask a question, or delegate a task. Supports file attachments and project tagging. Example triggers: "send this to bob", "email alice about the bug", "notify the team".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Recipient email address (e.g., bob@nothing.email, alice@gmail.com)" },
+        text: { type: "string", description: "Message body. For code discussions, include file paths and line numbers." },
+        agent: { type: "string", description: 'Your agent identity (e.g., "claude-code", "cursor"). Auto-detected from MCP context.' },
+        subject: { type: "string", description: `Subject line. Auto-generated from first ${NMP_DEFAULTS.subjectMaxLength} chars if omitted.` },
+        type: { type: "string", enum: [...NMP_TYPES], description: "Message intent: share (FYI), question (expects reply), reply, notify (no reply expected)" },
+        project: { type: "string", description: 'Project name for grouping (e.g., "backend-refactor"). Messages with same project are grouped together.' },
+        labels: { type: "array", items: { type: "string" }, description: 'Tags for categorization (e.g., ["code-review", "urgent"])' },
+        files: { type: "array", items: { type: "string" }, description: 'Absolute file paths to attach (e.g., ["/path/to/file.ts"])' },
+        require: { type: "array", items: { type: "string" }, description: 'Capabilities the recipient must have (e.g., ["code-review"]). Recipient can reject if they lack the capability.' },
+        priority: { type: "string", enum: [...NMP_PRIORITIES], description: 'Urgency level. Use "urgent" sparingly.' }
+      },
+      required: ["to", "text"]
+    }
+  },
+  nothing_inbox: {
+    name: "nothing_inbox",
+    description: 'Check inbox for received messages. Use when the user asks "any new messages?", "check my mail", "what did bob send?", or "show messages from gmail". Supports filtering by channel (gmail/qq/nothing), sender, project, and labels.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        unread: { type: "boolean", description: "Only unread messages (default: true). Set false to see all." },
+        project: { type: "string", description: "Filter by project name" },
+        label: { type: "string", description: "Filter by label" },
+        channel: { type: "string", description: "Filter by email channel: gmail, qq, outlook, nothing, local" },
+        source: { type: "string", enum: ["nmp", "external"], description: 'Filter by message type: "nmp" for Agent messages, "external" for regular emails' },
+        agent: { type: "string", description: 'Filter by sending agent name (exact match, e.g., "claude-code", "cursor", "codex")' },
+        limit: { type: "number", description: `Max messages to return (default: ${NMP_DEFAULTS.messageLimit})` }
+      }
+    }
+  },
+  nothing_sent: {
+    name: "nothing_sent",
+    description: 'Check sent messages and their delivery status. Use when the user asks "did my message arrive?", "delivery status", or "what did I send?". Shows 6 statuses: queued \u2192 sent \u2192 delivered \u2192 read \u2192 replied / failed.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: `Max messages to return (default: ${NMP_DEFAULTS.messageLimit})` },
+        project: { type: "string", description: "Filter by project" }
+      }
+    }
+  },
+  nothing_read: {
+    name: "nothing_read",
+    description: 'Read a specific message in full. Use when the user says "open that message", "read it", "show me the details". Returns complete content, code context, attachments, and thread history. Marks message as read.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Message ID (from inbox or sent listing)" }
+      },
+      required: ["id"]
+    }
+  },
+  nothing_reply: {
+    name: "nothing_reply",
+    description: 'Reply to a message within its thread. Use when the user says "reply to that", "tell them yes", "respond with...". Automatically inherits project, labels, and thread context from the original message.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Message ID to reply to" },
+        text: { type: "string", description: "Reply body" },
+        files: { type: "array", items: { type: "string" }, description: "File paths to attach" }
+      },
+      required: ["id", "text"]
+    }
+  },
+  nothing_projects: {
+    name: "nothing_projects",
+    description: 'List all projects with message counts and unread status. Use when the user asks "what projects do I have?", "project overview", or "which projects have unread messages?".',
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  nothing_report: {
+    name: "nothing_report",
+    description: 'Generate an activity report showing messages sent/received, project breakdown, items needing reply, and top threads. Use when the user asks "weekly summary", "what happened this week?", "give me a report", or "any messages I missed?".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        period: { type: "string", enum: ["today", "week", "month"], description: "Time period (default: week)" },
+        project: { type: "string", description: "Filter report to a specific project" }
+      }
+    }
+  }
+};
+export {
+  NMP_ATTACHMENT_NAME,
+  NMP_CHANNEL_TYPES,
+  NMP_COMPLIANCE,
+  NMP_DEFAULTS,
+  NMP_ERROR_CODES,
+  NMP_HEADERS,
+  NMP_LIMITS,
+  NMP_PRIORITIES,
+  NMP_SOURCES,
+  NMP_STATUSES,
+  NMP_TOOLS,
+  NMP_TYPES,
+  NMP_VERSION,
+  Registry,
+  TOKEN_PERMISSIONS,
+  generateMarkdown,
+  generatePlainText,
+  parseMarkdown,
+  resolveSchema,
+  schemaRegistry,
+  validateMarkdown,
+  validatePayload
+};

package/dist/types-BBAct0Gd.d.ts

@@ -0,0 +1,140 @@
+/** NMP protocol version */
+declare const NMP_VERSION = 1;
+/** Message types */
+declare const NMP_TYPES: readonly ["share", "question", "reply", "notify"];
+type NmpType = typeof NMP_TYPES[number];
+/** Priority levels */
+declare const NMP_PRIORITIES: readonly ["urgent", "normal", "low"];
+type NmpPriority = typeof NMP_PRIORITIES[number];
+/** Message statuses */
+declare const NMP_STATUSES: readonly ["queued", "sent", "delivered", "read", "replied", "failed"];
+type NmpStatus = typeof NMP_STATUSES[number];
+/** Message sources */
+declare const NMP_SOURCES: readonly ["nmp", "external"];
+type NmpSource = typeof NMP_SOURCES[number];
+/** Channel backend types */
+declare const NMP_CHANNEL_TYPES: readonly ["nothing", "smtp", "stalwart", "local"];
+type NmpChannelType = typeof NMP_CHANNEL_TYPES[number];
+/** Token permissions */
+declare const TOKEN_PERMISSIONS: readonly ["send", "inbox", "read", "reply", "manage"];
+type TokenPermission = typeof TOKEN_PERMISSIONS[number];
+/** Error codes */
+declare const NMP_ERROR_CODES: readonly ["capability_not_supported", "schema_mismatch", "rate_limited", "rejected", "expired", "version_unsupported", "payload_too_large"];
+type NmpErrorCode = typeof NMP_ERROR_CODES[number];
+/** Compliance levels */
+declare const NMP_COMPLIANCE: {
+    readonly NONE: 0;
+    readonly BASIC: 1;
+    readonly FULL: 2;
+};
+type NmpComplianceLevel = typeof NMP_COMPLIANCE[keyof typeof NMP_COMPLIANCE];
+declare const NMP_DEFAULTS: {
+    readonly subjectMaxLength: 50;
+    readonly messageLimit: 20;
+    readonly dailyMessageLimit: 50;
+    readonly tokenRateLimit: 10;
+    readonly priority: NmpPriority;
+    readonly type: NmpType;
+};
+declare const NMP_LIMITS: {
+    readonly maxEmailSize: number;
+    readonly maxAttachments: 5;
+    readonly maxJsonSize: number;
+    readonly maxMarkdownSize: number;
+    readonly maxPlainTextSize: number;
+};
+declare const NMP_HEADERS: {
+    readonly version: "X-NMP-Version";
+    readonly type: "X-NMP-Type";
+    readonly agent: "X-NMP-Agent";
+    readonly project: "X-NMP-Project";
+    readonly labels: "X-NMP-Labels";
+    readonly priority: "X-NMP-Priority";
+    readonly expires: "X-NMP-Expires";
+    readonly capabilities: "X-NMP-Capabilities";
+    readonly require: "X-NMP-Require";
+    readonly replySchema: "X-NMP-Reply-Schema";
+    readonly signature: "X-NMP-Signature";
+};
+/** Reserved attachment filename for NMP markdown */
+declare const NMP_ATTACHMENT_NAME = "nmp.md";
+/** Channel configuration */
+interface NmpChannelConfig {
+    id: string;
+    name: string;
+    type: NmpChannelType;
+    email: string;
+    smtp_host?: string;
+    smtp_port?: number;
+    imap_host?: string;
+    imap_port?: number;
+    is_primary: boolean;
+    is_active: boolean;
+}
+/** Code context attached to a message */
+interface NmpContext {
+    repo?: string;
+    file?: string;
+    lines?: string;
+    language?: string;
+}
+/** Error returned in reply messages */
+interface NmpError {
+    code: NmpErrorCode;
+    message: string;
+    supported?: string[];
+}
+/** NMP JSON payload (Part 3) — metadata only, no message body */
+interface NmpPayload {
+    nmp: number;
+    type: NmpType;
+    agent?: string;
+    project?: string;
+    labels?: string[];
+    priority?: NmpPriority;
+    expires?: string;
+    ack?: boolean;
+    context?: NmpContext;
+    files?: string[];
+    capabilities?: string[];
+    require?: string[];
+    reply_schema?: Record<string, unknown>;
+    source?: NmpSource;
+    error?: NmpError;
+}
+/** Parsed nmp.md content (Part 2) */
+interface NmpMarkdown {
+    type: NmpType;
+    agent?: string;
+    project?: string;
+    labels?: string[];
+    priority?: NmpPriority;
+    expires?: string;
+    content: string;
+    context?: NmpContext;
+    capabilities?: string[];
+    require?: string[];
+    attachments?: string[];
+    replySchema?: string[];
+}
+/** Full NMP message (combined from all parts) */
+interface NmpMessage {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    date: string;
+    inReplyTo?: string;
+    references?: string[];
+    payload: NmpPayload;
+    content: string;
+    attachments?: NmpAttachment[];
+}
+/** Attachment metadata */
+interface NmpAttachment {
+    filename: string;
+    size: number;
+    contentType: string;
+}
+
+export { type NmpPayload as N, TOKEN_PERMISSIONS as T, type NmpMarkdown as a, type NmpComplianceLevel as b, NMP_ATTACHMENT_NAME as c, NMP_CHANNEL_TYPES as d, NMP_COMPLIANCE as e, NMP_DEFAULTS as f, NMP_ERROR_CODES as g, NMP_HEADERS as h, NMP_LIMITS as i, NMP_PRIORITIES as j, NMP_SOURCES as k, NMP_STATUSES as l, NMP_TYPES as m, NMP_VERSION as n, type NmpAttachment as o, type NmpChannelConfig as p, type NmpChannelType as q, type NmpContext as r, type NmpError as s, type NmpErrorCode as t, type NmpMessage as u, type NmpPriority as v, type NmpSource as w, type NmpStatus as x, type NmpType as y, type TokenPermission as z };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@nothingmail/nmp",
+  "version": "0.1.0",
+  "description": "Nothing Message Protocol — AI-native communication protocol",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.1"
+  },
+  "license": "MIT"
+}