unimemory 0.0.1 → 1.0.0

package/README.md

@@ -1,13 +1,108 @@
 # UniMemory
 
-UniMemory is a unified memory layer for AI agents.
+AI memory management for your applications.
 
-This package is currently a placeholder while the core system is under active development.
+## Installation
 
-Planned:
-- Local-first memory core
-- System-level capture (macOS)
-- SDK for Node, browser extensions, and agents
-- Search and recall APIs
+```bash
+npm install unimemory
+```
+
+## Quick Start
+
+```typescript
+import UniMemory from 'unimemory';
+
+const client = new UniMemory({
+  apiKey: process.env.UNIMEMORY_API_KEY
+});
+
+// Add a memory
+await client.addMemory({
+  content: "User prefers dark mode",
+  sourceApp: "my-app"
+});
+
+// Search memories
+const results = await client.search("user preferences");
+console.log(results.results);
+```
+
+## API
+
+### `new UniMemory(config)`
+
+Create a new UniMemory client.
+
+```typescript
+const client = new UniMemory({
+  apiKey: 'um_live_xxx...',
+  baseUrl: 'https://api.unimemory.ai/api/v1' // optional
+});
+```
+
+### `client.addMemory(options)`
+
+Add a memory.
+
+```typescript
+const result = await client.addMemory({
+  content: "Important information to remember",
+  sourceApp: "my-app",        // optional
+  userId: "user123",          // optional
+  metadata: { key: "value" }  // optional
+});
+
+// Result:
+// {
+//   wasWorthRemembering: true,
+//   reason: "Contains user preference",
+//   extractedCount: 1,
+//   memories: [{ id: "...", wasDeduplicated: false }]
+// }
+```
+
+### `client.search(query, options?)`
+
+Search memories.
+
+```typescript
+const results = await client.search("user preferences", {
+  limit: 10,
+  userId: "user123",
+  minSalience: 0.5
+});
+
+// Result:
+// {
+//   results: [{ id, content, sector, salience, score, tags }],
+//   total: 1,
+//   query: "user preferences"
+// }
+```
+
+### `client.listMemories(options?)`
+
+List memories.
+
+```typescript
+const memories = await client.listMemories({
+  limit: 50,
+  offset: 0,
+  userId: "user123",
+  sector: "semantic"
+});
+```
+
+### `client.deleteMemory(memoryId)`
+
+Delete a memory.
+
+```typescript
+await client.deleteMemory("memory-id-here");
+```
+
+## License
+
+MIT
 
-Follow development at: https://github.com/unimemory

package/dist/index.d.mts

@@ -0,0 +1,86 @@
+/**
+ * UniMemory SDK
+ * AI memory management for your applications
+ */
+interface UniMemoryConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface AddMemoryOptions {
+    content: string;
+    sourceApp?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AddMemoryResponse {
+    wasWorthRemembering: boolean;
+    reason?: string;
+    extractedCount: number;
+    memories?: Array<{
+        id: string;
+        wasDeduplicated: boolean;
+    }>;
+}
+interface SearchOptions {
+    limit?: number;
+    userId?: string;
+    minSalience?: number;
+    debug?: boolean;
+}
+interface SearchResult {
+    id: string;
+    content: string;
+    sector?: string;
+    salience: number;
+    score: number;
+    tags: string[];
+}
+interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    query: string;
+}
+interface Memory {
+    id: string;
+    content: string;
+    sector?: string;
+    salience: number;
+    tags: string[];
+    createdAt: string;
+}
+interface ListMemoriesOptions {
+    limit?: number;
+    offset?: number;
+    userId?: string;
+    sector?: string;
+}
+interface ListMemoriesResponse {
+    memories: Memory[];
+    total: number;
+}
+declare class UniMemory {
+    private apiKey;
+    private baseUrl;
+    constructor(config: UniMemoryConfig);
+    private request;
+    /**
+     * Add a memory to UniMemory
+     */
+    addMemory(options: AddMemoryOptions): Promise<AddMemoryResponse>;
+    /**
+     * Search memories
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResponse>;
+    /**
+     * List memories
+     */
+    listMemories(options?: ListMemoriesOptions): Promise<ListMemoriesResponse>;
+    /**
+     * Delete a memory
+     */
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+export { type AddMemoryOptions, type AddMemoryResponse, type ListMemoriesOptions, type ListMemoriesResponse, type Memory, type SearchOptions, type SearchResponse, type SearchResult, UniMemory, type UniMemoryConfig, UniMemory as default };

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * UniMemory SDK
+ * AI memory management for your applications
+ */
+interface UniMemoryConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface AddMemoryOptions {
+    content: string;
+    sourceApp?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AddMemoryResponse {
+    wasWorthRemembering: boolean;
+    reason?: string;
+    extractedCount: number;
+    memories?: Array<{
+        id: string;
+        wasDeduplicated: boolean;
+    }>;
+}
+interface SearchOptions {
+    limit?: number;
+    userId?: string;
+    minSalience?: number;
+    debug?: boolean;
+}
+interface SearchResult {
+    id: string;
+    content: string;
+    sector?: string;
+    salience: number;
+    score: number;
+    tags: string[];
+}
+interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    query: string;
+}
+interface Memory {
+    id: string;
+    content: string;
+    sector?: string;
+    salience: number;
+    tags: string[];
+    createdAt: string;
+}
+interface ListMemoriesOptions {
+    limit?: number;
+    offset?: number;
+    userId?: string;
+    sector?: string;
+}
+interface ListMemoriesResponse {
+    memories: Memory[];
+    total: number;
+}
+declare class UniMemory {
+    private apiKey;
+    private baseUrl;
+    constructor(config: UniMemoryConfig);
+    private request;
+    /**
+     * Add a memory to UniMemory
+     */
+    addMemory(options: AddMemoryOptions): Promise<AddMemoryResponse>;
+    /**
+     * Search memories
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResponse>;
+    /**
+     * List memories
+     */
+    listMemories(options?: ListMemoriesOptions): Promise<ListMemoriesResponse>;
+    /**
+     * Delete a memory
+     */
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+export { type AddMemoryOptions, type AddMemoryResponse, type ListMemoriesOptions, type ListMemoriesResponse, type Memory, type SearchOptions, type SearchResponse, type SearchResult, UniMemory, type UniMemoryConfig, UniMemory as default };

package/dist/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  UniMemory: () => UniMemory,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var UniMemoryError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "UniMemoryError";
+  }
+};
+var UniMemory = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new UniMemoryError("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.unimemory.ai/api/v1";
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey
+    };
+    const options = {
+      method,
+      headers
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new UniMemoryError(
+        error.detail || `Request failed with status ${response.status}`,
+        response.status,
+        error.code
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Add a memory to UniMemory
+   */
+  async addMemory(options) {
+    const response = await this.request("POST", "/memories/add", {
+      content: options.content,
+      source_app: options.sourceApp,
+      user_id: options.userId,
+      metadata: options.metadata
+    });
+    return {
+      wasWorthRemembering: response.was_worth_remembering,
+      reason: response.reason,
+      extractedCount: response.extracted_count,
+      memories: response.memories?.map((m) => ({
+        id: m.id,
+        wasDeduplicated: m.was_deduplicated
+      }))
+    };
+  }
+  /**
+   * Search memories
+   */
+  async search(query, options) {
+    const response = await this.request("POST", "/search", {
+      query,
+      limit: options?.limit,
+      user_id: options?.userId,
+      min_salience: options?.minSalience,
+      debug: options?.debug
+    });
+    return {
+      results: response.results,
+      total: response.total,
+      query: response.query
+    };
+  }
+  /**
+   * List memories
+   */
+  async listMemories(options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", options.limit.toString());
+    if (options?.offset) params.set("offset", options.offset.toString());
+    if (options?.userId) params.set("user_id", options.userId);
+    if (options?.sector) params.set("sector", options.sector);
+    const queryString = params.toString();
+    const path = `/memories${queryString ? `?${queryString}` : ""}`;
+    const response = await this.request("GET", path);
+    return {
+      memories: response.memories.map((m) => ({
+        id: m.id,
+        content: m.content,
+        sector: m.sector,
+        salience: m.salience,
+        tags: m.tags,
+        createdAt: m.created_at
+      })),
+      total: response.total
+    };
+  }
+  /**
+   * Delete a memory
+   */
+  async deleteMemory(memoryId) {
+    return this.request("DELETE", `/memories/${memoryId}`);
+  }
+};
+var index_default = UniMemory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UniMemory
+});

package/dist/index.mjs

@@ -0,0 +1,114 @@
+// src/index.ts
+var UniMemoryError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "UniMemoryError";
+  }
+};
+var UniMemory = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new UniMemoryError("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.unimemory.ai/api/v1";
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey
+    };
+    const options = {
+      method,
+      headers
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new UniMemoryError(
+        error.detail || `Request failed with status ${response.status}`,
+        response.status,
+        error.code
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Add a memory to UniMemory
+   */
+  async addMemory(options) {
+    const response = await this.request("POST", "/memories/add", {
+      content: options.content,
+      source_app: options.sourceApp,
+      user_id: options.userId,
+      metadata: options.metadata
+    });
+    return {
+      wasWorthRemembering: response.was_worth_remembering,
+      reason: response.reason,
+      extractedCount: response.extracted_count,
+      memories: response.memories?.map((m) => ({
+        id: m.id,
+        wasDeduplicated: m.was_deduplicated
+      }))
+    };
+  }
+  /**
+   * Search memories
+   */
+  async search(query, options) {
+    const response = await this.request("POST", "/search", {
+      query,
+      limit: options?.limit,
+      user_id: options?.userId,
+      min_salience: options?.minSalience,
+      debug: options?.debug
+    });
+    return {
+      results: response.results,
+      total: response.total,
+      query: response.query
+    };
+  }
+  /**
+   * List memories
+   */
+  async listMemories(options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", options.limit.toString());
+    if (options?.offset) params.set("offset", options.offset.toString());
+    if (options?.userId) params.set("user_id", options.userId);
+    if (options?.sector) params.set("sector", options.sector);
+    const queryString = params.toString();
+    const path = `/memories${queryString ? `?${queryString}` : ""}`;
+    const response = await this.request("GET", path);
+    return {
+      memories: response.memories.map((m) => ({
+        id: m.id,
+        content: m.content,
+        sector: m.sector,
+        salience: m.salience,
+        tags: m.tags,
+        createdAt: m.created_at
+      })),
+      total: response.total
+    };
+  }
+  /**
+   * Delete a memory
+   */
+  async deleteMemory(memoryId) {
+    return this.request("DELETE", `/memories/${memoryId}`);
+  }
+};
+var index_default = UniMemory;
+export {
+  UniMemory,
+  index_default as default
+};

package/package.json

@@ -1,16 +1,42 @@
 {
   "name": "unimemory",
-  "version": "0.0.1",
-  "description": "Unified memory layer for AI Agents.",
-  "main": "index.js",
+  "version": "1.0.0",
+  "description": "UniMemory SDK - AI memory management for your applications",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "memory",
-    "context",
     "ai",
-    "agents",
-    "unified-memory",
-    "recall"
+    "embeddings",
+    "search",
+    "vector",
+    "llm"
   ],
-  "author": "Shreyas Gurav",
-  "license": "MIT"
-}
+  "author": "UniMemory",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shreyasgurav/UniMemory"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist"
+  ]
+}
+

package/index.js

@@ -1,2 +0,0 @@
-// UniMemory placeholder package
-module.exports = {};