SELECT * FROM patterns
WHERE domain = 'api-development'
AND confidence > 0.8
ORDER BY success_rate DESC
LIMIT 10;

-- Store a memory
INSERT INTO memory (key, namespace, value)
VALUES ('api_config', 'backend', '{"timeout": 30, "retries": 3}');

-- Query memory
SELECT * FROM memory
WHERE namespace = 'backend'
AND key LIKE '%api%';

# Store a value
npx claude-flow@alpha memory store api_key "sk-123456" --namespace config

# Query by key
npx claude-flow@alpha memory query "api" --namespace config

# List all memories
npx claude-flow@alpha memory list --namespace config

# Delete a memory
npx claude-flow@alpha memory delete api_key --namespace config

# Query patterns semantically
npx claude-flow@alpha memory query "authentication best practices" --reasoningbank

# Search patterns
npx claude-flow@alpha memory search "API optimization" --namespace backend

# Store pattern with learning
npx claude-flow@alpha memory store api_pattern "Use JWT with refresh tokens" --reasoningbank

# Initialize swarm with model
npx claude-flow@alpha hive-mind init --topology mesh

# Swarms use collective_memory table automatically
# No additional configuration needed!

# Sessions are automatically tracked in sessions table
npx claude-flow@alpha hooks session-restore --session-id swarm-123

# View session metrics
npx claude-flow@alpha hooks session-end --export-metrics

# List all tables
sqlite3 ~/.swarm/memory.db ".tables"

# Should show:
# collective_memory   metadata            patterns
# memory              pattern_embeddings  session_metrics
# memory_entries      pattern_links       sessions

# Check pattern count
sqlite3 ~/.swarm/memory.db "SELECT COUNT(*) FROM patterns"

# Check memory entries
sqlite3 ~/.swarm/memory.db "SELECT COUNT(*) FROM memory"

# Check all tables
sqlite3 ~/.swarm/memory.db "
SELECT name, (SELECT COUNT(*) FROM ' || name || ') as count
FROM sqlite_master
WHERE type='table' AND name NOT LIKE 'sqlite_%'
ORDER BY name
"

cd /workspaces/claude-code-flow/docs/reasoningbank/models
node fix-schema-compatibility.cjs

# This will:
# 1. Create backups (.backup files)
# 2. Add missing tables
# 3. Optimize database
# 4. Generate compatibility reports

CREATE TABLE memory (
    key TEXT NOT NULL,
    namespace TEXT NOT NULL DEFAULT 'default',
    value TEXT NOT NULL,
    ttl INTEGER,
    access_count INTEGER NOT NULL DEFAULT 0,
    last_accessed_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP,
    metadata TEXT,
    PRIMARY KEY (key, namespace)
);

CREATE TABLE memory_entries (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    key TEXT NOT NULL,
    value TEXT NOT NULL,
    namespace TEXT NOT NULL DEFAULT 'default',
    timestamp INTEGER NOT NULL,
    source TEXT,
    UNIQUE(key, namespace)
);

CREATE TABLE collective_memory (
    id TEXT PRIMARY KEY,
    swarm_id TEXT,
    key TEXT NOT NULL,
    value TEXT,
    type TEXT DEFAULT 'knowledge',
    confidence REAL DEFAULT 1.0,
    created_by TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    accessed_at DATETIME,
    access_count INTEGER DEFAULT 0,
    ttl INTEGER,
    metadata TEXT,
    embedding TEXT
);

CREATE TABLE patterns (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    description TEXT NOT NULL,
    context TEXT,
    success_rate REAL DEFAULT 0.5,
    confidence REAL DEFAULT 0.5,
    domain TEXT,
    tags TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE pattern_embeddings (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    pattern_id INTEGER NOT NULL,
    embedding TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (pattern_id) REFERENCES patterns(id)
);

node fix-schema-compatibility.cjs

sqlite3 ~/.swarm/memory.db "PRAGMA journal_mode=WAL"

sqlite3 ~/.swarm/memory.db "REINDEX; ANALYZE; VACUUM;"

cp ~/.swarm/memory.db.backup ~/.swarm/memory.db

cp ~/.swarm/memory.db ~/.swarm/memory.db.backup-$(date +%Y%m%d)

cp ~/.swarm/memory.db.backup-20251015 ~/.swarm/memory.db

sqlite3 ~/.swarm/memory.db .dump > memory-backup.sql

sqlite3 new-memory.db < memory-backup.sql

const Database = require('better-sqlite3');
const db = new Database(process.env.HOME + '/.swarm/memory.db');

// Store memory
db.prepare(`
    INSERT INTO memory (key, namespace, value)
    VALUES (?, ?, ?)
    ON CONFLICT(key, namespace) DO UPDATE SET value = excluded.value
`).run('api_key', 'config', 'sk-123');

// Query memory
const memories = db.prepare(`
    SELECT * FROM memory WHERE namespace = ?
`).all('config');

// Query patterns
const patterns = db.prepare(`
    SELECT p.*, pe.embedding
    FROM patterns p
    JOIN pattern_embeddings pe ON p.id = pe.pattern_id
    WHERE p.domain = ? AND p.confidence > ?
    ORDER BY p.confidence DESC
    LIMIT 10
`).all('api-development', 0.8);

import sqlite3
import os

db = sqlite3.connect(f"{os.environ['HOME']}/.swarm/memory.db")

# Store memory
db.execute("""
    INSERT INTO memory (key, namespace, value)
    VALUES (?, ?, ?)
    ON CONFLICT(key, namespace) DO UPDATE SET value = excluded.value
""", ('api_key', 'config', 'sk-123'))
db.commit()

# Query patterns
patterns = db.execute("""
    SELECT * FROM patterns
    WHERE domain = ? AND confidence > ?
    ORDER BY confidence DESC
    LIMIT 10
""", ('api-development', 0.8)).fetchall()