@agent-diaries/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Swapnil Netankar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+  <h1>🧠 Agent Diaries Core</h1>
+  <p><strong>The lightweight, lock-safe memory layer for edge AI agents.</strong></p>
+
+  [![NPM Version](https://img.shields.io/npm/v/@agent-diaries/core?style=for-the-badge&logo=npm&color=CB3837)](https://www.npmjs.com/package/@agent-diaries/core)
+  [![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+</div>
+
+<br />
+
+**Agent Diaries** is a framework-agnostic state management library designed specifically for autonomous AI agents. It gives your agents a persistent "diary" memory, allowing them to remember past actions, avoid infinite loops, and share context across highly concurrent swarm deployments.
+
+---
+
+## ✨ Features
+
+- **🚫 Deduplication & Loop Prevention:** Automatically filter out tasks your agent has already seen.
+- **🔒 Fully Lock-Safe:** Uses atomic spin-locks and advisory locks to completely eliminate race conditions, even with 50+ concurrent agents processing the exact same task simultaneously.
+- **☁️ Cloud-Native Adapters:** Comes with official adapters for **Redis** and **PostgreSQL** for Vercel/AWS Lambda deployments, plus a local file adapter for development.
+- **⚡ Ultra-Lightweight:** Negligible bundle size, zero heavy dependencies.
+
+## 📦 Installation
+
+Install the core package:
+
+```bash
+npm install @agent-diaries/core
+```
+
+If you plan to use a specific cloud adapter, install its peer dependency:
+
+```bash
+npm install ioredis    # For Redis Storage
+npm install pg         # For PostgreSQL Storage
+```
+
+## 🚀 Quick Start
+
+Initialize an `AgentDiary` and wrap your LLM calls to prevent duplicate executions.
+
+```typescript
+import { AgentDiary } from '@agent-diaries/core';
+
+async function runAgent() {
+  const diary = new AgentDiary({ agentId: 'data-collector' });
+  const currentTask = 'Download Q3 Financial Report';
+
+  // 1. claimTask is ATOMIC. It acquires a distributed lock and registers the task.
+  // If two agents try to claim it at the exact same millisecond, only ONE succeeds.
+  const isNew = await diary.claimTask(currentTask);
+  
+  if (!isNew) {
+    const pastResult = await diary.getTaskResult(currentTask);
+    console.log(`[Agent] ⏩ Skipping task. Result: ${pastResult}`);
+    return pastResult;
+  }
+
+  // 2. Execute your expensive LLM logic safely
+  console.log(`[Agent] ⚙️ Executing: "${currentTask}"...`);
+  const result = "Found 2 warnings, no critical errors."; 
+
+  // 3. Update the pending task with the final result
+  await diary.writeTaskResult(currentTask, result);
+  console.log(`[Agent] ✅ Task complete. Diary updated!`);
+  return result;
+}
+
+runAgent();
+```
+
+## ☁️ Cloud Storage Adapters (Production)
+
+Local file storage is great for local development, but serverless environments (Vercel, AWS Lambda) have ephemeral filesystems. For production, you **must** use one of our lock-safe cloud adapters.
+
+### Redis (Best for Serverless)
+The `RedisStorage` adapter uses atomic `SETNX` distributed spin-locks to guarantee race-condition safety across thousands of concurrent Vercel Edge functions.
+
+```typescript
+import { AgentDiary } from '@agent-diaries/core';
+import { RedisStorage } from '@agent-diaries/core/dist/adapters/redis';
+import Redis from 'ioredis';
+
+const diary = new AgentDiary({ 
+  agentId: 'cloud-bot',
+  storage: new RedisStorage({ redis: new Redis(process.env.REDIS_URL) }) 
+});
+```
+
+### PostgreSQL (Best for Stateful Architectures)
+The `PostgresStorage` adapter natively uses `pg_advisory_lock` to ensure absolute row-level safety during concurrent task evaluation.
+
+```typescript
+import { AgentDiary } from '@agent-diaries/core';
+import { PostgresStorage } from '@agent-diaries/core/dist/adapters/postgres';
+import { Pool } from 'pg';
+
+const pgStorage = new PostgresStorage({ pool: new Pool({ connectionString: process.env.DATABASE_URL }) });
+await pgStorage.initialize(); // Creates the state table
+
+const diary = new AgentDiary({ 
+  agentId: 'db-bot',
+  storage: pgStorage 
+});
+```
+
+## 📚 API Reference
+
+- **`diary.claimTask(title: string): Promise<boolean>`**
+  Atomically checks if a task has been processed. If not, acquires a lock and claims it as 'pending'. Returns `true` if successfully claimed.
+- **`diary.getTaskResult(title: string): Promise<string | undefined>`**
+  Retrieves the exact string output/result from a previously completed task so your agent can instantly reuse it.
+- **`diary.filterNewTasks(tasks: T[]): Promise<T[]>`**
+  Pass in an array of task objects. Returns only the tasks that the agent has *not* seen yet.
+- **`diary.writeTaskResult(title: string, result: string): Promise<void>`**
+  Saves the final result into the agent's memory bank after the agent finishes its work.
+
+## 📄 License
+
+This project is licensed under the MIT License.

package/dist/adapters/postgres.d.ts

@@ -0,0 +1,17 @@
+import { StorageAdapter } from '../storage';
+import { Pool } from 'pg';
+export declare class PostgresStorage<T> implements StorageAdapter<T> {
+    private pool;
+    private tableName;
+    constructor(options: {
+        pool: Pool;
+        tableName?: string;
+    });
+    /**
+     * Initializes the database table. Must be called before first use.
+     */
+    initialize(): Promise<void>;
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    withLock<R>(key: string, fn: () => Promise<R>): Promise<R>;
+}

package/dist/adapters/postgres.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresStorage = void 0;
+const crypto = __importStar(require("crypto"));
+class PostgresStorage {
+    pool;
+    tableName;
+    constructor(options) {
+        this.pool = options.pool;
+        this.tableName = options.tableName || 'agent_diaries';
+    }
+    /**
+     * Initializes the database table. Must be called before first use.
+     */
+    async initialize() {
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id VARCHAR(255) PRIMARY KEY,
+        data JSONB NOT NULL
+      );
+    `);
+    }
+    async get(key) {
+        const res = await this.pool.query(`SELECT data FROM ${this.tableName} WHERE id = $1`, [key]);
+        if (res.rows.length === 0)
+            return null;
+        return res.rows[0].data;
+    }
+    async set(key, value) {
+        await this.pool.query(`
+      INSERT INTO ${this.tableName} (id, data)
+      VALUES ($1, $2)
+      ON CONFLICT (id) DO UPDATE SET data = EXCLUDED.data;
+    `, [key, JSON.stringify(value)]);
+    }
+    async withLock(key, fn) {
+        const client = await this.pool.connect();
+        // Convert string key to a 32-bit integer for Postgres advisory locks
+        const lockId = crypto.createHash('sha256').update(key).digest().readInt32BE(0);
+        try {
+            await client.query('SELECT pg_advisory_lock($1)', [lockId]);
+            return await fn();
+        }
+        finally {
+            await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
+            client.release();
+        }
+    }
+}
+exports.PostgresStorage = PostgresStorage;

package/dist/adapters/redis.d.ts

@@ -0,0 +1,14 @@
+import { StorageAdapter } from '../storage';
+import Redis from 'ioredis';
+export declare class RedisStorage<T> implements StorageAdapter<T> {
+    private redis;
+    private prefix;
+    constructor(options: {
+        redis: Redis;
+        prefix?: string;
+    });
+    private getKey;
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    withLock<R>(key: string, fn: () => Promise<R>): Promise<R>;
+}

package/dist/adapters/redis.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStorage = void 0;
+class RedisStorage {
+    redis;
+    prefix;
+    constructor(options) {
+        this.redis = options.redis;
+        this.prefix = options.prefix || 'agent-diaries:';
+    }
+    getKey(key) {
+        return `${this.prefix}${key}`;
+    }
+    async get(key) {
+        const data = await this.redis.get(this.getKey(key));
+        if (!data)
+            return null;
+        try {
+            return JSON.parse(data);
+        }
+        catch (e) {
+            console.error(`[RedisStorage] Failed to parse JSON for key ${key}`);
+            return null;
+        }
+    }
+    async set(key, value) {
+        const data = JSON.stringify(value);
+        await this.redis.set(this.getKey(key), data);
+    }
+    async withLock(key, fn) {
+        const lockKey = `${this.getKey(key)}:lock`;
+        const lockValue = Date.now().toString() + Math.random().toString();
+        const lockTtlMs = 10000; // 10 seconds max lock
+        const acquireLock = async () => {
+            const result = await this.redis.set(lockKey, lockValue, 'PX', lockTtlMs, 'NX');
+            return result === 'OK';
+        };
+        // Spin-lock until we acquire it
+        while (!(await acquireLock())) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            // Safe release: ensure we only delete the lock if we still own it
+            const luaScript = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+            await this.redis.eval(luaScript, 1, lockKey, lockValue);
+        }
+    }
+}
+exports.RedisStorage = RedisStorage;

package/dist/diary.d.ts

@@ -0,0 +1,56 @@
+import { StorageAdapter } from './storage';
+export interface TaskRecord {
+    title: string;
+    signature: string;
+    result?: string;
+    timestamp: number;
+}
+export interface AgentState {
+    lastRun: number;
+    seenSignatures: string[];
+    runCount: number;
+    history: TaskRecord[];
+}
+export interface AgentDiaryOptions {
+    agentId: string;
+    storage?: StorageAdapter<AgentState>;
+    maxHistory?: number;
+}
+export declare class AgentDiary {
+    private agentId;
+    private storage;
+    private maxHistory;
+    constructor(options: AgentDiaryOptions);
+    private emptyState;
+    /**
+     * Generates a normalized signature for a task title.
+     */
+    static normalizeSignature(title: string): string;
+    /**
+     * Reads the current diary state (without locking).
+     */
+    readDiary(): Promise<AgentState>;
+    /**
+     * Atomically attempts to claim a task.
+     * Returns true if successfully claimed (first time seen), false if already claimed/processed.
+     */
+    claimTask(title: string): Promise<boolean>;
+    /**
+     * Checks if a task has already been processed by the agent.
+     */
+    hasProcessedTask(title: string): Promise<boolean>;
+    /**
+     * Retrieves the stored result of a previously processed task, if available.
+     */
+    getTaskResult(title: string): Promise<string | undefined>;
+    /**
+     * Filters out items that the agent has already processed.
+     */
+    filterNewTasks<T extends {
+        title: string;
+    }>(tasks: T[]): Promise<T[]>;
+    /**
+     * Updates a claimed task with its final result.
+     */
+    writeTaskResult(title: string, result?: string): Promise<void>;
+}

package/dist/diary.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDiary = void 0;
+const storage_1 = require("./storage");
+class AgentDiary {
+    agentId;
+    storage;
+    maxHistory;
+    constructor(options) {
+        this.agentId = options.agentId;
+        // Use local file storage by default if none provided
+        this.storage = options.storage || new storage_1.LocalFileStorage();
+        this.maxHistory = options.maxHistory || 500;
+    }
+    emptyState() {
+        return {
+            lastRun: 0,
+            seenSignatures: [],
+            runCount: 0,
+            history: [],
+        };
+    }
+    /**
+     * Generates a normalized signature for a task title.
+     */
+    static normalizeSignature(title) {
+        return (title || '').toLowerCase().trim().replace(/\s+/g, ' ');
+    }
+    /**
+     * Reads the current diary state (without locking).
+     */
+    async readDiary() {
+        const state = await this.storage.get(`diary_${this.agentId}`);
+        return state ?? this.emptyState();
+    }
+    /**
+     * Atomically attempts to claim a task.
+     * Returns true if successfully claimed (first time seen), false if already claimed/processed.
+     */
+    async claimTask(title) {
+        const signature = AgentDiary.normalizeSignature(title);
+        return await this.storage.withLock(`diary_${this.agentId}`, async () => {
+            const state = await this.readDiary();
+            if (state.seenSignatures.includes(signature)) {
+                return false; // Task already exists
+            }
+            // Claim it immediately to prevent race conditions
+            const record = {
+                title,
+                signature,
+                timestamp: Date.now()
+            };
+            state.history = [record, ...state.history].slice(0, this.maxHistory);
+            // Fix Desync Bug: seenSignatures is strictly derived from the sliced history
+            state.seenSignatures = state.history.map(r => r.signature);
+            state.runCount += 1;
+            state.lastRun = Date.now();
+            await this.storage.set(`diary_${this.agentId}`, state);
+            return true;
+        });
+    }
+    /**
+     * Checks if a task has already been processed by the agent.
+     */
+    async hasProcessedTask(title) {
+        const signature = AgentDiary.normalizeSignature(title);
+        const state = await this.readDiary();
+        return state.seenSignatures.includes(signature);
+    }
+    /**
+     * Retrieves the stored result of a previously processed task, if available.
+     */
+    async getTaskResult(title) {
+        const signature = AgentDiary.normalizeSignature(title);
+        const state = await this.readDiary();
+        const record = state.history.find(r => r.signature === signature);
+        return record?.result;
+    }
+    /**
+     * Filters out items that the agent has already processed.
+     */
+    async filterNewTasks(tasks) {
+        const state = await this.readDiary();
+        return tasks.filter(task => {
+            const signature = AgentDiary.normalizeSignature(task.title);
+            return !state.seenSignatures.includes(signature);
+        });
+    }
+    /**
+     * Updates a claimed task with its final result.
+     */
+    async writeTaskResult(title, result) {
+        const signature = AgentDiary.normalizeSignature(title);
+        await this.storage.withLock(`diary_${this.agentId}`, async () => {
+            const state = await this.readDiary();
+            const recordIndex = state.history.findIndex(r => r.signature === signature);
+            if (recordIndex !== -1) {
+                state.history[recordIndex].result = result;
+                state.history[recordIndex].timestamp = Date.now(); // update timestamp
+                state.lastRun = Date.now();
+                await this.storage.set(`diary_${this.agentId}`, state);
+            }
+            else {
+                // If not claimed first, we insert it
+                const record = { title, signature, result, timestamp: Date.now() };
+                state.history = [record, ...state.history].slice(0, this.maxHistory);
+                state.seenSignatures = state.history.map(r => r.signature);
+                state.runCount += 1;
+                state.lastRun = Date.now();
+                await this.storage.set(`diary_${this.agentId}`, state);
+            }
+        });
+    }
+}
+exports.AgentDiary = AgentDiary;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './storage';
+export * from './diary';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./storage"), exports);
+__exportStar(require("./diary"), exports);

package/dist/storage.d.ts

@@ -0,0 +1,18 @@
+export interface StorageAdapter<T> {
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    /**
+     * Acquires a lock on the key, executes the critical section, and releases the lock.
+     */
+    withLock<R>(key: string, fn: () => Promise<R>): Promise<R>;
+}
+export declare class LocalFileStorage<T> implements StorageAdapter<T> {
+    private baseDir;
+    constructor(options?: {
+        baseDir?: string;
+    });
+    private getFilePath;
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    withLock<R>(key: string, fn: () => Promise<R>): Promise<R>;
+}

package/dist/storage.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFileStorage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const lockfile = __importStar(require("proper-lockfile"));
+class LocalFileStorage {
+    baseDir;
+    constructor(options = {}) {
+        this.baseDir = options.baseDir || path.join(process.cwd(), '.agent-diaries');
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+        }
+    }
+    getFilePath(key) {
+        const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return path.join(this.baseDir, `${safeKey}.json`);
+    }
+    async get(key) {
+        const filePath = this.getFilePath(key);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (e) {
+            console.error(`[LocalFileStorage] Error reading key ${key}:`, e);
+            return null;
+        }
+    }
+    async set(key, value) {
+        const filePath = this.getFilePath(key);
+        try {
+            const data = JSON.stringify(value, null, 2);
+            await fs.promises.writeFile(filePath, data, 'utf-8');
+        }
+        catch (e) {
+            console.error(`[LocalFileStorage] Error writing key ${key}:`, e);
+            throw e;
+        }
+    }
+    async withLock(key, fn) {
+        const filePath = this.getFilePath(key);
+        // Ensure the file exists so we can lock it (proper-lockfile requires the file/dir to exist)
+        if (!fs.existsSync(filePath)) {
+            await fs.promises.writeFile(filePath, "null", 'utf-8');
+        }
+        const release = await lockfile.lock(filePath, {
+            retries: { retries: 100, minTimeout: 10, maxTimeout: 100 },
+            realpath: false
+        });
+        try {
+            return await fn();
+        }
+        finally {
+            await release();
+        }
+    }
+}
+exports.LocalFileStorage = LocalFileStorage;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@agent-diaries/core",
+  "version": "0.1.0",
+  "description": "The lightweight, framework-agnostic memory layer for edge AI agents.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "memory",
+    "diary",
+    "local"
+  ],
+  "author": "swapwarick_n",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swapwarick/agent-diaries-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/swapwarick/agent-diaries-sdk/issues"
+  },
+  "homepage": "https://github.com/swapwarick/agent-diaries-sdk#readme",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/pg": "^8.20.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@vitest/coverage-v8": "^4.1.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.5"
+  },
+  "dependencies": {
+    "ioredis": "^5.10.1",
+    "pg": "^8.20.0",
+    "proper-lockfile": "^4.1.2"
+  }
+}