@hir4ta/memoria 0.13.2 → 0.14.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memoria",
   "description": "A plugin that provides long-term memory for Claude Code. It automatically saves context lost during auto-compact, offering features for session restoration, recording technical decisions, and learning developer patterns.",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "author": {
     "name": "hir4ta"
   },

package/README.ja.md

@@ -74,6 +74,16 @@ Claude Code内で以下を実行
 /plugin install memoria@memoria-marketplace
 ```
 
+プロジェクトでmemoriaを初期化：
+
+```bash
+# Claude Code内で
+/memoria:init
+
+# またはターミナルから
+npx @hir4ta/memoria --init
+```
+
 Claude Codeを再起動して完了
 
 ## アップデート
@@ -129,6 +139,7 @@ Continue from a previous session? Use `/memoria:resume <id>`
 
 | コマンド | 説明 |
 | --------- | ------ |
+| `/memoria:init` | プロジェクトでmemoriaを初期化 |
 | `/memoria:save` | 全データ抽出: 要約・判断・パターン・ルール |
 | `/memoria:plan [トピック]` | 記憶参照 + ソクラティック質問 + タスク分割 |
 | `/memoria:resume [id]` | セッションを再開（ID省略で一覧表示） |
@@ -227,14 +238,27 @@ flowchart TB
 
 ## データ保存
 
-すべてのデータは `.memoria/` ディレクトリに保存
+memoriaは**ハイブリッドストレージ**方式でプライバシーと共有を両立：
+
+| ストレージ | 用途 | 共有 |
+|-----------|------|------|
+| **JSON** | 要約、決定、パターン、ルール | Git管理（チーム共有） |
+| **SQLite** | 会話履歴、バックアップ | ローカル専用（.gitignore） |
+
+**なぜハイブリッド？**
+- **プライバシー**: 会話履歴（interactions）は各開発者のローカルのみ
+- **軽量化**: JSONファイルが100KB+から約5KBに軽量化（interactions除外）
+- **将来対応**: セマンティック検索用のembeddingsテーブル準備済み
+
+### ディレクトリ構成
 
 ```text
 .memoria/
+├── local.db          # SQLite（ローカル専用、.gitignore）
 ├── tags.json         # タグマスターファイル（93タグ、表記揺れ防止）
-├── sessions/         # セッション履歴（自動 + 手動保存）
+├── sessions/         # セッションメタデータ
 │   └── YYYY/MM/
-│       └── {id}.json
+│       └── {id}.json # メタデータのみ（interactionsはSQLite）
 ├── decisions/        # 技術的な判断（/saveから）
 │   └── YYYY/MM/
 │       └── {id}.json
@@ -245,11 +269,11 @@ flowchart TB
 └── reports/          # 週次レポート (YYYY-MM)
 ```
 
-Gitでバージョン管理可能です。`.gitignore` に追加するかはプロジェクトに応じて判断してください。
+Gitでバージョン管理可能です。`local.db`は自動で`.gitignore`に追加されます。
 
 ### セッションJSONスキーマ
 
-全てのセッションデータは単一のJSONファイルに保存されます：
+セッションメタデータはJSONに保存（interactionsはプライバシー保護のためSQLiteに保存）：
 
 ```json
 {
@@ -264,15 +288,6 @@ Gitでバージョン管理可能です。`.gitignore` に追加するかはプ
     "projectDir": "/path/to/project",
     "user": { "name": "tanaka", "email": "tanaka@example.com" }
   },
-  "interactions": [
-    {
-      "id": "int-001",
-      "timestamp": "2026-01-27T10:15:00Z",
-      "user": "認証機能を実装して",
-      "thinking": "思考プロセスの重要なポイント",
-      "assistant": "RS256署名でJWT認証を実装しました"
-    }
-  ],
   "metrics": {
     "userMessages": 5,
     "assistantResponses": 5,
@@ -282,7 +297,6 @@ Gitでバージョン管理可能です。`.gitignore` に追加するかはプ
   "files": [
     { "path": "src/auth/jwt.ts", "action": "create" }
   ],
-  "preCompactBackups": [],
   "resumedFrom": "def45678",
   "status": "complete",
 

package/README.md

@@ -74,6 +74,16 @@ Run the following in Claude Code:
 /plugin install memoria@memoria-marketplace
 ```
 
+Then initialize memoria in your project:
+
+```bash
+# In Claude Code
+/memoria:init
+
+# Or from terminal
+npx @hir4ta/memoria --init
+```
+
 Restart Claude Code to complete installation.
 
 ## Update
@@ -129,6 +139,7 @@ Continue from a previous session? Use `/memoria:resume <id>`
 
 | Command | Description |
 |---------|-------------|
+| `/memoria:init` | Initialize memoria in current project |
 | `/memoria:save` | Extract all data: summary, decisions, patterns, rules |
 | `/memoria:plan [topic]` | Memory-informed design + Socratic questions + task breakdown |
 | `/memoria:resume [id]` | Resume session (show list if ID omitted) |
@@ -227,14 +238,27 @@ flowchart TB
 
 ## Data Storage
 
-All data is stored in `.memoria/` directory:
+memoria uses a **hybrid storage** approach for privacy and collaboration:
+
+| Storage | Purpose | Sharing |
+|---------|---------|---------|
+| **JSON** | Summaries, decisions, patterns, rules | Git-managed (team shared) |
+| **SQLite** | Interactions, backups | Local only (.gitignore) |
+
+**Why hybrid?**
+- **Privacy**: Conversation history (interactions) stays local to each developer
+- **Lightweight**: JSON files reduced from 100KB+ to ~5KB (interactions excluded)
+- **Future-ready**: Embeddings table prepared for semantic search
+
+### Directory Structure
 
 ```text
 .memoria/
+├── local.db          # SQLite (local only, .gitignore)
 ├── tags.json         # Tag master file (93 tags, prevents notation variations)
-├── sessions/         # Session history (YYYY/MM)
+├── sessions/         # Session metadata (YYYY/MM)
 │   └── YYYY/MM/
-│       └── {id}.json # All session data (auto + manual save)
+│       └── {id}.json # Metadata only (interactions in SQLite)
 ├── decisions/        # Technical decisions (from /save)
 │   └── YYYY/MM/
 │       └── {id}.json
@@ -245,11 +269,11 @@ All data is stored in `.memoria/` directory:
 └── reports/          # Weekly reports (YYYY-MM)
 ```
 
-Git-manageable. Add to `.gitignore` based on your project needs.
+Git-manageable. The `local.db` file is automatically added to `.gitignore`.
 
 ### Session JSON Schema
 
-All session data is stored in a single JSON file:
+Session metadata is stored in JSON (interactions are stored in SQLite for privacy):
 
 ```json
 {
@@ -264,15 +288,6 @@ All session data is stored in a single JSON file:
     "projectDir": "/path/to/project",
     "user": { "name": "tanaka", "email": "tanaka@example.com" }
   },
-  "interactions": [
-    {
-      "id": "int-001",
-      "timestamp": "2026-01-27T10:15:00Z",
-      "user": "Implement authentication",
-      "thinking": "Key insights from thinking process",
-      "assistant": "Implemented JWT auth with RS256 signing"
-    }
-  ],
   "metrics": {
     "userMessages": 5,
     "assistantResponses": 5,
@@ -282,7 +297,6 @@ All session data is stored in a single JSON file:
   "files": [
     { "path": "src/auth/jwt.ts", "action": "create" }
   ],
-  "preCompactBackups": [],
   "resumedFrom": "def45678",
   "status": "complete",
 

package/bin/memoria.js

@@ -5,6 +5,18 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+// Suppress Node.js SQLite experimental warning (must be before dynamic import)
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+  if (name === "warning" && data?.name === "ExperimentalWarning" && data?.message?.includes("SQLite")) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+
+// Dynamic import to ensure warning suppression is active
+const { DatabaseSync } = await import("node:sqlite");
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -17,6 +29,7 @@ function showHelp() {
 memoria - Claude Code Long-term Memory Plugin
 
 Usage:
+  memoria --init         Initialize .memoria directory in current project
   memoria --dashboard    Start the web dashboard
   memoria -d             Same as above (short form)
   memoria --port <port>  Specify port (default: 7777)
@@ -24,6 +37,7 @@ Usage:
 
 Examples:
   cd /path/to/your/project
+  npx @hir4ta/memoria --init
   npx @hir4ta/memoria --dashboard
   npx @hir4ta/memoria -d --port 8080
 `);
@@ -33,11 +47,81 @@ function checkMemoriaDir() {
   const memoriaDir = path.join(projectRoot, ".memoria");
   if (!fs.existsSync(memoriaDir)) {
     console.log(`\nWARNING: .memoria directory not found: ${projectRoot}`);
-    console.log(
-      "         Run a Claude Code session with the memoria plugin installed",
-    );
-    console.log("         in this project to create the data directory.");
+    console.log("         Run: npx @hir4ta/memoria --init");
+  }
+}
+
+function initMemoria() {
+  const memoriaDir = path.join(projectRoot, ".memoria");
+  const sessionsDir = path.join(memoriaDir, "sessions");
+  const rulesDir = path.join(memoriaDir, "rules");
+  const patternsDir = path.join(memoriaDir, "patterns");
+  const tagsPath = path.join(memoriaDir, "tags.json");
+  const dbPath = path.join(memoriaDir, "local.db");
+
+  // Check if already initialized
+  if (fs.existsSync(memoriaDir)) {
+    console.log(`memoria is already initialized: ${memoriaDir}`);
+    return;
+  }
+
+  // Create directories
+  fs.mkdirSync(sessionsDir, { recursive: true });
+  fs.mkdirSync(rulesDir, { recursive: true });
+  fs.mkdirSync(patternsDir, { recursive: true });
+
+  // Copy default tags.json
+  const defaultTagsPath = path.join(packageDir, "hooks", "default-tags.json");
+  if (fs.existsSync(defaultTagsPath)) {
+    fs.copyFileSync(defaultTagsPath, tagsPath);
+  }
+
+  // Initialize rules files
+  const now = new Date().toISOString();
+  const rulesTemplate = JSON.stringify(
+    {
+      schemaVersion: 1,
+      createdAt: now,
+      updatedAt: now,
+      items: [],
+    },
+    null,
+    2,
+  );
+
+  fs.writeFileSync(
+    path.join(rulesDir, "review-guidelines.json"),
+    rulesTemplate,
+  );
+  fs.writeFileSync(path.join(rulesDir, "dev-rules.json"), rulesTemplate);
+
+  // Initialize SQLite database
+  const schemaPath = path.join(packageDir, "lib", "schema.sql");
+  try {
+    const db = new DatabaseSync(dbPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    if (fs.existsSync(schemaPath)) {
+      const schema = fs.readFileSync(schemaPath, "utf-8");
+      db.exec(schema);
+    }
+    db.close();
+  } catch (error) {
+    console.error(`Warning: Failed to initialize SQLite database: ${error.message}`);
   }
+
+  console.log(`memoria initialized: ${memoriaDir}`);
+  console.log(`
+Created:
+  ${sessionsDir}/
+  ${rulesDir}/
+  ${patternsDir}/
+  ${tagsPath}
+  ${rulesDir}/review-guidelines.json
+  ${rulesDir}/dev-rules.json
+  ${dbPath}
+
+You can now use memoria with Claude Code in this project.
+`);
 }
 
 function getPort() {
@@ -90,7 +174,9 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
   process.exit(0);
 }
 
-if (args.includes("--dashboard") || args.includes("-d")) {
+if (args.includes("--init")) {
+  initMemoria();
+} else if (args.includes("--dashboard") || args.includes("-d")) {
   startDashboard();
 } else {
   console.error(`ERROR: Unknown option: ${args.join(" ")}`);

package/dist/lib/db.js

@@ -0,0 +1,167 @@
+// lib/db.ts
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var originalEmit = process.emit;
+process.emit = function(name, data, ...args) {
+  if (name === "warning" && typeof data === "object" && data?.name === "ExperimentalWarning" && data?.message?.includes("SQLite")) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+var { DatabaseSync } = await import("node:sqlite");
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getCurrentUser() {
+  try {
+    return execSync("git config user.name", { encoding: "utf-8" }).trim();
+  } catch {
+    try {
+      return execSync("whoami", { encoding: "utf-8" }).trim();
+    } catch {
+      return "unknown";
+    }
+  }
+}
+function getDbPath(memoriaDir) {
+  return join(memoriaDir, "local.db");
+}
+function initDatabase(memoriaDir) {
+  const dbPath = getDbPath(memoriaDir);
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  const schemaPath = join(__dirname, "schema.sql");
+  if (existsSync(schemaPath)) {
+    const schema = readFileSync(schemaPath, "utf-8");
+    db.exec(schema);
+  }
+  return db;
+}
+function openDatabase(memoriaDir) {
+  const dbPath = getDbPath(memoriaDir);
+  if (!existsSync(dbPath)) {
+    return null;
+  }
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  return db;
+}
+function insertInteractions(db, interactions) {
+  const insert = db.prepare(`
+    INSERT INTO interactions (session_id, owner, role, content, thinking, tool_calls, timestamp, is_compact_summary)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  db.exec("BEGIN TRANSACTION");
+  try {
+    for (const item of interactions) {
+      insert.run(
+        item.session_id,
+        item.owner,
+        item.role,
+        item.content,
+        item.thinking || null,
+        item.tool_calls || null,
+        item.timestamp,
+        item.is_compact_summary || 0
+      );
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+function getInteractions(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(sessionId);
+}
+function getInteractionsByOwner(db, sessionId, owner) {
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id = ? AND owner = ?
+    ORDER BY timestamp ASC
+  `);
+  return stmt.all(sessionId, owner);
+}
+function hasInteractions(db, sessionId, owner) {
+  const stmt = db.prepare(`
+    SELECT COUNT(*) as count FROM interactions
+    WHERE session_id = ? AND owner = ?
+  `);
+  const result = stmt.get(sessionId, owner);
+  return result.count > 0;
+}
+function insertPreCompactBackup(db, backup) {
+  const stmt = db.prepare(`
+    INSERT INTO pre_compact_backups (session_id, owner, interactions)
+    VALUES (?, ?, ?)
+  `);
+  stmt.run(backup.session_id, backup.owner, backup.interactions);
+}
+function getLatestBackup(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM pre_compact_backups
+    WHERE session_id = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `);
+  return stmt.get(sessionId) || null;
+}
+function getAllBackups(db, sessionId) {
+  const stmt = db.prepare(`
+    SELECT * FROM pre_compact_backups
+    WHERE session_id = ?
+    ORDER BY created_at ASC
+  `);
+  return stmt.all(sessionId);
+}
+function searchInteractions(db, query, limit = 10) {
+  const stmt = db.prepare(`
+    SELECT i.session_id, i.content, i.thinking
+    FROM interactions_fts fts
+    JOIN interactions i ON fts.rowid = i.id
+    WHERE interactions_fts MATCH ?
+    LIMIT ?
+  `);
+  return stmt.all(query, limit);
+}
+function deleteInteractions(db, sessionId) {
+  const stmt = db.prepare("DELETE FROM interactions WHERE session_id = ?");
+  stmt.run(sessionId);
+}
+function deleteBackups(db, sessionId) {
+  const stmt = db.prepare(
+    "DELETE FROM pre_compact_backups WHERE session_id = ?"
+  );
+  stmt.run(sessionId);
+}
+function getDbStats(db) {
+  const interactionsCount = db.prepare("SELECT COUNT(*) as count FROM interactions").get();
+  const backupsCount = db.prepare("SELECT COUNT(*) as count FROM pre_compact_backups").get();
+  return {
+    interactions: interactionsCount.count,
+    backups: backupsCount.count
+  };
+}
+export {
+  deleteBackups,
+  deleteInteractions,
+  getAllBackups,
+  getCurrentUser,
+  getDbPath,
+  getDbStats,
+  getInteractions,
+  getInteractionsByOwner,
+  getLatestBackup,
+  hasInteractions,
+  initDatabase,
+  insertInteractions,
+  insertPreCompactBackup,
+  openDatabase,
+  searchInteractions
+};