1246 lines
65 KiB
JavaScript
1246 lines
65 KiB
JavaScript
const parseJsonArray = (value) => {
|
|
if (!value) return [];
|
|
try {
|
|
const parsed = JSON.parse(value);
|
|
return Array.isArray(parsed) ? parsed : [];
|
|
} catch {
|
|
return [];
|
|
}
|
|
};
|
|
|
|
const buildPersonaSnapshot = (persona) => JSON.stringify({
|
|
name: persona.name,
|
|
pronouns: persona.pronouns,
|
|
appearance: persona.appearance,
|
|
background: persona.background,
|
|
details: persona.details,
|
|
example_dialogues: persona.example_dialogues,
|
|
persona_type: persona.persona_type,
|
|
source_market_id: persona.source_market_id ?? null,
|
|
source_creator_username: persona.source_creator_username ?? null
|
|
});
|
|
|
|
const MARKET_SORT_ORDERS = {
|
|
best: "pm.favorite_count DESC, rating_average DESC, pm.usage_count DESC, datetime(pm.created_at) DESC, pm.id DESC",
|
|
newest: "datetime(pm.created_at) DESC, pm.id DESC",
|
|
most_favorited: "pm.favorite_count DESC, rating_average DESC, pm.usage_count DESC, datetime(pm.created_at) DESC, pm.id DESC",
|
|
most_popular: "pm.usage_count DESC, pm.favorite_count DESC, rating_average DESC, datetime(pm.created_at) DESC, pm.id DESC",
|
|
top_rated: "rating_average DESC, pm.rating_count DESC, pm.favorite_count DESC, datetime(pm.created_at) DESC, pm.id DESC",
|
|
alphabetical: "LOWER(pm.name) ASC, datetime(pm.created_at) DESC, pm.id DESC"
|
|
};
|
|
|
|
function normalizeMarketSort(sort) {
|
|
const normalized = String(sort || "best").trim().toLowerCase().replace(/-/g, "_");
|
|
return MARKET_SORT_ORDERS[normalized] ? normalized : "best";
|
|
}
|
|
|
|
function normalizeMarketPersonaType(personaType) {
|
|
return ["assistant", "user"].includes(personaType) ? personaType : null;
|
|
}
|
|
|
|
export function createRepositories(db, config) {
|
|
const statements = {
|
|
insertUser: db.prepare("INSERT INTO users (username, password) VALUES (?, ?)"),
|
|
getUser: db.prepare("SELECT username, password, session_version FROM users WHERE username = ?"),
|
|
updateUsername: db.prepare("UPDATE users SET username = ? WHERE username = ?"),
|
|
updatePassword: db.prepare("UPDATE users SET password = ? WHERE username = ?"),
|
|
incrementSessionVersion: db.prepare("UPDATE users SET session_version = COALESCE(session_version, 0) + 1 WHERE username = ?"),
|
|
insertChatSession: db.prepare(
|
|
"INSERT INTO chat_sessions (username, title, assistant_persona_id, user_persona_id, folder_name, is_pinned, archived_at, scenario_prompt, scenario_summary) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
|
|
),
|
|
listChatSessions: db.prepare(`
|
|
SELECT cs.id,
|
|
CASE
|
|
WHEN cs.assistant_persona_id IS NOT NULL THEN COALESCE(p.name, cs.title)
|
|
ELSE cs.title
|
|
END AS title,
|
|
cs.title AS stored_title,
|
|
cs.assistant_persona_id,
|
|
p.name AS assistant_persona_name,
|
|
cs.user_persona_id,
|
|
up.name AS user_persona_name,
|
|
cs.folder_name,
|
|
cs.is_pinned,
|
|
cs.archived_at,
|
|
cs.scenario_prompt,
|
|
cs.scenario_summary,
|
|
cs.context_summary,
|
|
cs.context_summary_message_id,
|
|
cs.active_leaf_message_id,
|
|
cs.preferred_model,
|
|
cs.temperature,
|
|
cs.context_length,
|
|
cs.response_length,
|
|
cs.system_instruction,
|
|
cs.created_at,
|
|
cs.updated_at
|
|
FROM chat_sessions cs
|
|
LEFT JOIN personas p ON p.id = cs.assistant_persona_id
|
|
LEFT JOIN personas up ON up.id = cs.user_persona_id
|
|
WHERE cs.username = ?
|
|
ORDER BY cs.is_pinned DESC, datetime(cs.updated_at) DESC
|
|
`),
|
|
countChatSessions: db.prepare("SELECT COUNT(*) as count FROM chat_sessions WHERE username = ?"),
|
|
getChatSession: db.prepare(`
|
|
SELECT cs.id,
|
|
CASE
|
|
WHEN cs.assistant_persona_id IS NOT NULL THEN COALESCE(p.name, cs.title)
|
|
ELSE cs.title
|
|
END AS title,
|
|
cs.title AS stored_title,
|
|
cs.assistant_persona_id,
|
|
p.name AS assistant_persona_name,
|
|
cs.user_persona_id,
|
|
up.name AS user_persona_name,
|
|
cs.folder_name,
|
|
cs.is_pinned,
|
|
cs.archived_at,
|
|
cs.scenario_prompt,
|
|
cs.scenario_summary,
|
|
cs.context_summary,
|
|
cs.context_summary_message_id,
|
|
cs.active_leaf_message_id,
|
|
cs.preferred_model,
|
|
cs.temperature,
|
|
cs.context_length,
|
|
cs.response_length,
|
|
cs.system_instruction,
|
|
cs.created_at,
|
|
cs.updated_at
|
|
FROM chat_sessions cs
|
|
LEFT JOIN personas p ON p.id = cs.assistant_persona_id
|
|
LEFT JOIN personas up ON up.id = cs.user_persona_id
|
|
WHERE cs.id = ?
|
|
AND cs.username = ?
|
|
`),
|
|
getChatSessionByParticipants: db.prepare(`
|
|
SELECT cs.id,
|
|
CASE
|
|
WHEN cs.assistant_persona_id IS NOT NULL THEN COALESCE(p.name, cs.title)
|
|
ELSE cs.title
|
|
END AS title,
|
|
cs.title AS stored_title,
|
|
cs.assistant_persona_id,
|
|
p.name AS assistant_persona_name,
|
|
cs.user_persona_id,
|
|
up.name AS user_persona_name,
|
|
cs.folder_name,
|
|
cs.is_pinned,
|
|
cs.archived_at,
|
|
cs.scenario_prompt,
|
|
cs.scenario_summary,
|
|
cs.context_summary,
|
|
cs.context_summary_message_id,
|
|
cs.active_leaf_message_id,
|
|
cs.preferred_model,
|
|
cs.temperature,
|
|
cs.context_length,
|
|
cs.response_length,
|
|
cs.system_instruction,
|
|
cs.created_at,
|
|
cs.updated_at
|
|
FROM chat_sessions cs
|
|
LEFT JOIN personas p ON p.id = cs.assistant_persona_id
|
|
LEFT JOIN personas up ON up.id = cs.user_persona_id
|
|
WHERE cs.username = ?
|
|
AND cs.assistant_persona_id = ?
|
|
AND ((cs.user_persona_id IS NULL AND ? IS NULL) OR cs.user_persona_id = ?)
|
|
ORDER BY cs.is_pinned DESC, datetime(cs.updated_at) DESC
|
|
LIMIT 1
|
|
`),
|
|
updateChatSessionTitle: db.prepare("UPDATE chat_sessions SET title = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND username = ?"),
|
|
updateChatSessionScene: db.prepare("UPDATE chat_sessions SET scenario_prompt = ?, scenario_summary = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND username = ?"),
|
|
updateChatContextSummary: db.prepare("UPDATE chat_sessions SET context_summary = ?, context_summary_message_id = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND username = ?"),
|
|
updateChatGenerationSettings: db.prepare(`
|
|
UPDATE chat_sessions
|
|
SET preferred_model = ?, temperature = ?, context_length = ?, response_length = ?, system_instruction = ?, updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ? AND username = ?
|
|
`),
|
|
updateChatActiveLeaf: db.prepare("UPDATE chat_sessions SET active_leaf_message_id = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND username = ?"),
|
|
setChatActiveLeafById: db.prepare("UPDATE chat_sessions SET active_leaf_message_id = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?"),
|
|
updateChatSessionOrganization: db.prepare(`
|
|
UPDATE chat_sessions
|
|
SET folder_name = ?,
|
|
is_pinned = ?,
|
|
archived_at = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
AND username = ?
|
|
`),
|
|
touchChatSession: db.prepare("UPDATE chat_sessions SET updated_at = CURRENT_TIMESTAMP WHERE id = ? AND username = ?"),
|
|
deleteChatSession: db.prepare("DELETE FROM chat_sessions WHERE id = ? AND username = ?"),
|
|
clearAssistantPersonaFromChats: db.prepare(`
|
|
UPDATE chat_sessions
|
|
SET assistant_persona_id = NULL,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE username = ?
|
|
AND assistant_persona_id = ?
|
|
`),
|
|
clearUserPersonaFromChats: db.prepare(`
|
|
UPDATE chat_sessions
|
|
SET user_persona_id = NULL,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE username = ?
|
|
AND user_persona_id = ?
|
|
`),
|
|
insertChatMessage: db.prepare("INSERT INTO chat_messages (chat_id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
|
|
updateChatMessageDelivery: db.prepare("UPDATE chat_messages SET delivery_status = ?, error_message = ? WHERE id = ? AND chat_id = ?"),
|
|
getChatMessages: db.prepare(`
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM chat_messages
|
|
WHERE chat_id = ?
|
|
ORDER BY id
|
|
`),
|
|
getRecentChatMessages: db.prepare(`
|
|
WITH RECURSIVE branch AS (
|
|
SELECT cm.* FROM chat_messages cm
|
|
JOIN chat_sessions cs ON cs.id = cm.chat_id
|
|
WHERE cm.chat_id = ?
|
|
AND cm.id = COALESCE(cs.active_leaf_message_id, (SELECT MAX(id) FROM chat_messages WHERE chat_id = cm.chat_id))
|
|
UNION ALL
|
|
SELECT parent.* FROM chat_messages parent
|
|
JOIN branch child ON child.parent_message_id = parent.id
|
|
)
|
|
SELECT id, role, content FROM branch
|
|
WHERE delivery_status != 'failed'
|
|
ORDER BY id DESC
|
|
LIMIT ?
|
|
`),
|
|
getRecentChatMessagesUpToId: db.prepare(`
|
|
WITH RECURSIVE branch AS (
|
|
SELECT * FROM chat_messages WHERE chat_id = ? AND id = ?
|
|
UNION ALL
|
|
SELECT parent.* FROM chat_messages parent
|
|
JOIN branch child ON child.parent_message_id = parent.id
|
|
)
|
|
SELECT id, role, content FROM branch
|
|
WHERE delivery_status != 'failed'
|
|
ORDER BY id DESC
|
|
LIMIT ?
|
|
`),
|
|
getActiveBranchMessages: db.prepare(`
|
|
WITH RECURSIVE branch AS (
|
|
SELECT cm.* FROM chat_messages cm
|
|
JOIN chat_sessions cs ON cs.id = cm.chat_id
|
|
WHERE cm.chat_id = ?
|
|
AND cm.id = COALESCE(cs.active_leaf_message_id, (SELECT MAX(id) FROM chat_messages WHERE chat_id = cm.chat_id))
|
|
UNION ALL
|
|
SELECT parent.* FROM chat_messages parent
|
|
JOIN branch child ON child.parent_message_id = parent.id
|
|
)
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used,
|
|
retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM branch ORDER BY id
|
|
`),
|
|
getSiblingChatMessages: db.prepare(`
|
|
SELECT id, role, content, parent_message_id
|
|
FROM chat_messages
|
|
WHERE chat_id = ? AND role = ? AND parent_message_id IS ?
|
|
ORDER BY id
|
|
`),
|
|
getLatestDescendantMessage: db.prepare(`
|
|
WITH RECURSIVE descendants AS (
|
|
SELECT id FROM chat_messages WHERE chat_id = ? AND id = ?
|
|
UNION ALL
|
|
SELECT child.id FROM chat_messages child JOIN descendants parent ON child.parent_message_id = parent.id
|
|
WHERE child.chat_id = ? AND child.delivery_status != 'failed'
|
|
)
|
|
SELECT cm.* FROM chat_messages cm JOIN descendants d ON d.id = cm.id ORDER BY cm.id DESC LIMIT 1
|
|
`),
|
|
getChatMessageById: db.prepare(`
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM chat_messages
|
|
WHERE id = ?
|
|
AND chat_id = ?
|
|
`),
|
|
getChatMessageByIndex: db.prepare(`
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM chat_messages
|
|
WHERE chat_id = ?
|
|
ORDER BY id
|
|
LIMIT 1 OFFSET ?
|
|
`),
|
|
getLatestChatMessage: db.prepare(`
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM chat_messages
|
|
WHERE chat_id = ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
`),
|
|
getPreviousUserMessage: db.prepare(`
|
|
SELECT id, role, content, model_name, retry_variants, retry_active_index, retry_retries_used, retry_prompt_message_id, delivery_status, error_message, parent_message_id, created_at
|
|
FROM chat_messages
|
|
WHERE chat_id = ?
|
|
AND role = 'user'
|
|
AND id < ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
`),
|
|
listChatMemories: db.prepare(`
|
|
SELECT id, username, chat_id, assistant_persona_id, user_persona_id, fact, created_at, updated_at
|
|
FROM chat_memories
|
|
WHERE chat_id = ?
|
|
AND username = ?
|
|
ORDER BY datetime(updated_at) DESC, id DESC
|
|
`),
|
|
getChatMemory: db.prepare(`
|
|
SELECT id, username, chat_id, assistant_persona_id, user_persona_id, fact, created_at, updated_at
|
|
FROM chat_memories
|
|
WHERE id = ?
|
|
AND chat_id = ?
|
|
AND username = ?
|
|
`),
|
|
insertChatMemory: db.prepare(`
|
|
INSERT INTO chat_memories (username, chat_id, assistant_persona_id, user_persona_id, fact)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`),
|
|
updateChatMemory: db.prepare(`
|
|
UPDATE chat_memories
|
|
SET fact = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
AND chat_id = ?
|
|
AND username = ?
|
|
`),
|
|
deleteChatMemory: db.prepare("DELETE FROM chat_memories WHERE id = ? AND chat_id = ? AND username = ?"),
|
|
getPersonaChatState: db.prepare(`
|
|
SELECT id,
|
|
username,
|
|
chat_id,
|
|
assistant_persona_id,
|
|
user_persona_id,
|
|
relationship_notes,
|
|
tone,
|
|
current_location,
|
|
goals,
|
|
unresolved_threads,
|
|
boundaries,
|
|
created_at,
|
|
updated_at
|
|
FROM persona_chat_state
|
|
WHERE chat_id = ?
|
|
AND username = ?
|
|
`),
|
|
upsertPersonaChatState: db.prepare(`
|
|
INSERT INTO persona_chat_state (
|
|
username,
|
|
chat_id,
|
|
assistant_persona_id,
|
|
user_persona_id,
|
|
relationship_notes,
|
|
tone,
|
|
current_location,
|
|
goals,
|
|
unresolved_threads,
|
|
boundaries
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(chat_id) DO UPDATE SET
|
|
username = excluded.username,
|
|
assistant_persona_id = excluded.assistant_persona_id,
|
|
user_persona_id = excluded.user_persona_id,
|
|
relationship_notes = excluded.relationship_notes,
|
|
tone = excluded.tone,
|
|
current_location = excluded.current_location,
|
|
goals = excluded.goals,
|
|
unresolved_threads = excluded.unresolved_threads,
|
|
boundaries = excluded.boundaries,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`),
|
|
updateChatMessage: db.prepare("UPDATE chat_messages SET content = ? WHERE id = ? AND chat_id = ?"),
|
|
updateChatMessageWithRetryState: db.prepare("UPDATE chat_messages SET content = ?, retry_variants = ?, retry_active_index = ?, retry_retries_used = ?, retry_prompt_message_id = ? WHERE id = ? AND chat_id = ?"),
|
|
deleteChatMessage: db.prepare("DELETE FROM chat_messages WHERE id = ? AND chat_id = ?"),
|
|
deleteChatMessages: db.prepare("DELETE FROM chat_messages WHERE chat_id = ?"),
|
|
searchChats: db.prepare(`
|
|
SELECT DISTINCT cs.id,
|
|
CASE
|
|
WHEN cs.assistant_persona_id IS NOT NULL THEN COALESCE(p.name, cs.title)
|
|
ELSE cs.title
|
|
END AS title,
|
|
cs.title AS stored_title,
|
|
cs.assistant_persona_id,
|
|
p.name AS assistant_persona_name,
|
|
cs.user_persona_id,
|
|
up.name AS user_persona_name,
|
|
cs.folder_name,
|
|
cs.is_pinned,
|
|
cs.archived_at,
|
|
cs.scenario_prompt,
|
|
cs.scenario_summary,
|
|
cs.context_summary,
|
|
cs.context_summary_message_id,
|
|
cs.active_leaf_message_id,
|
|
cs.preferred_model,
|
|
cs.temperature,
|
|
cs.context_length,
|
|
cs.response_length,
|
|
cs.system_instruction,
|
|
cs.created_at,
|
|
cs.updated_at,
|
|
cm.content AS matched_content
|
|
FROM chat_sessions cs
|
|
LEFT JOIN personas p ON p.id = cs.assistant_persona_id
|
|
LEFT JOIN personas up ON up.id = cs.user_persona_id
|
|
LEFT JOIN chat_messages cm ON cm.chat_id = cs.id
|
|
WHERE cs.username = ?
|
|
AND (
|
|
LOWER(CASE
|
|
WHEN cs.assistant_persona_id IS NOT NULL THEN COALESCE(p.name, cs.title)
|
|
ELSE cs.title
|
|
END) LIKE ?
|
|
OR LOWER(COALESCE(cm.content, '')) LIKE ?
|
|
)
|
|
ORDER BY cs.is_pinned DESC, datetime(cs.updated_at) DESC
|
|
`),
|
|
listPersonasByType: db.prepare(`
|
|
SELECT id, name, pronouns, appearance, background, details, example_dialogues, persona_type,
|
|
source_market_id, source_creator_username, created_at, updated_at
|
|
FROM personas
|
|
WHERE username = ?
|
|
AND persona_type = ?
|
|
ORDER BY datetime(updated_at) DESC
|
|
`),
|
|
listAllPersonas: db.prepare(`
|
|
SELECT id, username, name, pronouns, appearance, background, details, example_dialogues, persona_type,
|
|
source_market_id, source_creator_username, created_at, updated_at
|
|
FROM personas
|
|
WHERE username = ?
|
|
ORDER BY datetime(updated_at) DESC
|
|
`),
|
|
getPersona: db.prepare(`
|
|
SELECT id, name, pronouns, appearance, background, details, example_dialogues, persona_type,
|
|
source_market_id, source_creator_username, created_at, updated_at
|
|
FROM personas
|
|
WHERE id = ?
|
|
AND username = ?
|
|
`),
|
|
insertPersona: db.prepare("INSERT INTO personas (username, name, pronouns, appearance, background, details, example_dialogues, persona_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"),
|
|
insertMarketPersona: db.prepare("INSERT INTO personas (username, name, pronouns, appearance, background, details, example_dialogues, persona_type, source_market_id, source_creator_username) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
|
|
getPersonaBySourceMarket: db.prepare(`
|
|
SELECT id
|
|
FROM personas
|
|
WHERE username = ?
|
|
AND source_market_id = ?
|
|
`),
|
|
updatePersona: db.prepare(`
|
|
UPDATE personas
|
|
SET name = ?,
|
|
pronouns = ?,
|
|
appearance = ?,
|
|
background = ?,
|
|
details = ?,
|
|
example_dialogues = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
AND username = ?
|
|
`),
|
|
deletePersona: db.prepare("DELETE FROM personas WHERE id = ? AND username = ?"),
|
|
getNextPersonaVersionNumber: db.prepare("SELECT COALESCE(MAX(version_number), 0) + 1 AS nextVersion FROM persona_versions WHERE persona_id = ?"),
|
|
insertPersonaVersion: db.prepare("INSERT INTO persona_versions (persona_id, username, version_number, snapshot_json) VALUES (?, ?, ?, ?)"),
|
|
listPersonaVersions: db.prepare(`
|
|
SELECT id, persona_id, username, version_number, snapshot_json, created_at
|
|
FROM persona_versions
|
|
WHERE persona_id = ?
|
|
AND username = ?
|
|
ORDER BY version_number DESC
|
|
`),
|
|
getPersonaVersion: db.prepare(`
|
|
SELECT id, persona_id, username, version_number, snapshot_json, created_at
|
|
FROM persona_versions
|
|
WHERE id = ?
|
|
AND persona_id = ?
|
|
AND username = ?
|
|
`),
|
|
getActivePersonaId: db.prepare("SELECT active_persona_id, active_user_persona_id FROM user_settings WHERE username = ?"),
|
|
setActiveUserPersona: db.prepare(`
|
|
INSERT INTO user_settings (username, active_user_persona_id)
|
|
VALUES (?, ?)
|
|
ON CONFLICT(username) DO UPDATE SET active_user_persona_id = excluded.active_user_persona_id
|
|
`),
|
|
getActiveUserPersona: db.prepare(`
|
|
SELECT p.id, p.name, p.pronouns, p.appearance, p.background, p.details, p.example_dialogues
|
|
FROM user_settings us
|
|
JOIN personas p ON p.id = us.active_user_persona_id
|
|
WHERE us.username = ?
|
|
`),
|
|
getAssistantPersonaForChat: db.prepare(`
|
|
SELECT p.id, p.name, p.pronouns, p.appearance, p.background, p.details, p.example_dialogues
|
|
FROM chat_sessions cs
|
|
JOIN personas p ON p.id = cs.assistant_persona_id
|
|
WHERE cs.id = ?
|
|
AND cs.username = ?
|
|
`),
|
|
getUserPersonaForChat: db.prepare(`
|
|
SELECT p.id, p.name, p.pronouns, p.appearance, p.background, p.details, p.example_dialogues
|
|
FROM chat_sessions cs
|
|
JOIN personas p ON p.id = cs.user_persona_id
|
|
WHERE cs.id = ?
|
|
AND cs.username = ?
|
|
`),
|
|
listMarketPersonas: db.prepare(`
|
|
SELECT pm.id, pm.persona_id, pm.creator_username, pm.name, pm.pronouns, pm.appearance, pm.background, pm.details,
|
|
pm.example_dialogues, pm.persona_type, pm.tags, pm.usage_count, pm.favorite_count, pm.rating_total, pm.rating_count,
|
|
pm.moderation_status, pm.moderation_notes, pm.created_at, pm.updated_at, pm.soft_deleted_at,
|
|
CASE WHEN pm.rating_count > 0 THEN CAST(pm.rating_total AS REAL) / pm.rating_count ELSE 0 END AS rating_average
|
|
FROM persona_market pm
|
|
WHERE pm.soft_deleted_at IS NULL
|
|
AND pm.moderation_status != 'rejected'
|
|
ORDER BY pm.favorite_count DESC, rating_average DESC, datetime(pm.updated_at) DESC
|
|
`),
|
|
listMarketPersonasAdmin: db.prepare(`
|
|
SELECT pm.id, pm.persona_id, pm.creator_username, pm.name, pm.pronouns, pm.appearance, pm.background, pm.details,
|
|
pm.example_dialogues, pm.persona_type, pm.tags, pm.usage_count, pm.favorite_count, pm.rating_total, pm.rating_count,
|
|
pm.moderation_status, pm.moderation_notes, pm.created_at, pm.updated_at, pm.soft_deleted_at,
|
|
CASE WHEN pm.rating_count > 0 THEN CAST(pm.rating_total AS REAL) / pm.rating_count ELSE 0 END AS rating_average
|
|
FROM persona_market pm
|
|
ORDER BY datetime(pm.updated_at) DESC
|
|
`),
|
|
getMarketPersona: db.prepare(`
|
|
SELECT pm.id, pm.persona_id, pm.creator_username, pm.name, pm.pronouns, pm.appearance, pm.background, pm.details,
|
|
pm.example_dialogues, pm.persona_type, pm.tags, pm.usage_count, pm.favorite_count, pm.rating_total, pm.rating_count,
|
|
pm.moderation_status, pm.moderation_notes, pm.soft_deleted_at,
|
|
CASE WHEN pm.rating_count > 0 THEN CAST(pm.rating_total AS REAL) / pm.rating_count ELSE 0 END AS rating_average
|
|
FROM persona_market pm
|
|
WHERE pm.id = ?
|
|
`),
|
|
getMarketPersonaByPersonaId: db.prepare(`
|
|
SELECT id, persona_id, creator_username, name, pronouns, appearance, background, details,
|
|
example_dialogues, persona_type, tags, usage_count, favorite_count, rating_total, rating_count,
|
|
moderation_status, moderation_notes, soft_deleted_at
|
|
FROM persona_market
|
|
WHERE persona_id = ?
|
|
AND creator_username = ?
|
|
`),
|
|
upsertMarketPersona: db.prepare(`
|
|
INSERT INTO persona_market (persona_id, creator_username, name, pronouns, appearance, background, details, example_dialogues, persona_type, tags)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(persona_id, creator_username) DO UPDATE SET
|
|
name = excluded.name,
|
|
pronouns = excluded.pronouns,
|
|
appearance = excluded.appearance,
|
|
background = excluded.background,
|
|
details = excluded.details,
|
|
example_dialogues = excluded.example_dialogues,
|
|
persona_type = excluded.persona_type,
|
|
tags = excluded.tags,
|
|
moderation_status = 'approved',
|
|
moderation_notes = NULL,
|
|
soft_deleted_at = NULL,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`),
|
|
listPublishedPersonaIds: db.prepare("SELECT persona_id FROM persona_market WHERE creator_username = ? AND soft_deleted_at IS NULL"),
|
|
insertMarketFavorite: db.prepare("INSERT OR IGNORE INTO persona_market_favorites (market_id, username) VALUES (?, ?)"),
|
|
deleteMarketFavorite: db.prepare("DELETE FROM persona_market_favorites WHERE market_id = ? AND username = ?"),
|
|
isMarketFavorite: db.prepare("SELECT 1 AS favorite FROM persona_market_favorites WHERE market_id = ? AND username = ?"),
|
|
recountMarketFavorites: db.prepare("UPDATE persona_market SET favorite_count = (SELECT COUNT(*) FROM persona_market_favorites WHERE market_id = ?) WHERE id = ?"),
|
|
upsertMarketRating: db.prepare(`
|
|
INSERT INTO persona_market_ratings (market_id, username, rating)
|
|
VALUES (?, ?, ?)
|
|
ON CONFLICT(market_id, username) DO UPDATE SET
|
|
rating = excluded.rating,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`),
|
|
recountMarketRatings: db.prepare(`
|
|
UPDATE persona_market
|
|
SET rating_total = COALESCE((SELECT SUM(rating) FROM persona_market_ratings WHERE market_id = ?), 0),
|
|
rating_count = COALESCE((SELECT COUNT(*) FROM persona_market_ratings WHERE market_id = ?), 0)
|
|
WHERE id = ?
|
|
`),
|
|
insertMarketReport: db.prepare("INSERT INTO persona_market_reports (market_id, reporter_username, reason, details) VALUES (?, ?, ?, ?)"),
|
|
listMarketReports: db.prepare(`
|
|
SELECT id, market_id, reporter_username, reason, details, status, created_at, updated_at
|
|
FROM persona_market_reports
|
|
ORDER BY CASE WHEN status = 'open' THEN 0 ELSE 1 END, datetime(created_at) DESC
|
|
`),
|
|
updateMarketReportStatus: db.prepare("UPDATE persona_market_reports SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?"),
|
|
updateMarketModeration: db.prepare(`
|
|
UPDATE persona_market
|
|
SET moderation_status = ?,
|
|
moderation_notes = ?,
|
|
soft_deleted_at = CASE WHEN ? THEN COALESCE(soft_deleted_at, CURRENT_TIMESTAMP) ELSE NULL END,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
`),
|
|
insertPromptTemplate: db.prepare(`
|
|
INSERT INTO prompt_templates (username, persona_id, name, description, category, prompt_text, starter_text, is_shared)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
`),
|
|
getPromptTemplate: db.prepare(`
|
|
SELECT id, username, persona_id, name, description, category, prompt_text, starter_text, is_shared, created_at, updated_at
|
|
FROM prompt_templates
|
|
WHERE id = ?
|
|
`),
|
|
updatePromptTemplate: db.prepare(`
|
|
UPDATE prompt_templates
|
|
SET name = ?,
|
|
description = ?,
|
|
category = ?,
|
|
prompt_text = ?,
|
|
starter_text = ?,
|
|
is_shared = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
AND (username = ? OR (username IS NULL AND ? = 'system'))
|
|
`),
|
|
deletePromptTemplate: db.prepare("DELETE FROM prompt_templates WHERE id = ? AND username = ?"),
|
|
listPromptTemplates: db.prepare(`
|
|
SELECT id, username, persona_id, name, description, category, prompt_text, starter_text, is_shared, created_at, updated_at
|
|
FROM prompt_templates
|
|
WHERE username = ?
|
|
OR (is_shared = 1)
|
|
OR (username IS NULL)
|
|
ORDER BY is_shared DESC, datetime(updated_at) DESC
|
|
`),
|
|
listPersonaPromptTemplates: db.prepare(`
|
|
SELECT id, username, persona_id, name, description, category, prompt_text, starter_text, is_shared, created_at, updated_at
|
|
FROM prompt_templates
|
|
WHERE (persona_id = ? AND (username = ? OR username IS NULL OR is_shared = 1))
|
|
OR (persona_id IS NULL AND (username = ? OR username IS NULL OR is_shared = 1))
|
|
ORDER BY is_shared DESC, datetime(updated_at) DESC
|
|
`),
|
|
getChatMessageCountForUser: db.prepare(`
|
|
SELECT COUNT(*) as count
|
|
FROM chat_messages cm
|
|
JOIN chat_sessions cs ON cs.id = cm.chat_id
|
|
WHERE cs.username = ?
|
|
`),
|
|
getPersonaCountForUser: db.prepare("SELECT COUNT(*) as count FROM personas WHERE username = ?"),
|
|
getPublishedPersonaCountForUser: db.prepare("SELECT COUNT(*) as count FROM persona_market WHERE creator_username = ? AND soft_deleted_at IS NULL"),
|
|
getRecentActivity: db.prepare(`
|
|
SELECT cs.id AS chat_id,
|
|
cs.title,
|
|
MAX(cm.created_at) AS last_message_at,
|
|
COUNT(cm.id) AS message_count
|
|
FROM chat_sessions cs
|
|
LEFT JOIN chat_messages cm ON cm.chat_id = cs.id
|
|
WHERE cs.username = ?
|
|
GROUP BY cs.id
|
|
ORDER BY datetime(MAX(COALESCE(cm.created_at, cs.updated_at))) DESC
|
|
LIMIT 5
|
|
`),
|
|
getMostUsedPersonas: db.prepare(`
|
|
SELECT p.id, p.name, COUNT(cs.id) AS usage_count
|
|
FROM personas p
|
|
LEFT JOIN chat_sessions cs ON cs.assistant_persona_id = p.id OR cs.user_persona_id = p.id
|
|
WHERE p.username = ?
|
|
GROUP BY p.id
|
|
ORDER BY usage_count DESC, datetime(p.updated_at) DESC
|
|
LIMIT 5
|
|
`),
|
|
getAverageChatLength: db.prepare(`
|
|
SELECT AVG(message_count) AS average_length
|
|
FROM (
|
|
SELECT COUNT(cm.id) AS message_count
|
|
FROM chat_sessions cs
|
|
LEFT JOIN chat_messages cm ON cm.chat_id = cs.id
|
|
WHERE cs.username = ?
|
|
GROUP BY cs.id
|
|
)
|
|
`),
|
|
getFavoriteModel: db.prepare(`
|
|
SELECT model_name, COUNT(*) AS usage_count
|
|
FROM chat_messages cm
|
|
JOIN chat_sessions cs ON cs.id = cm.chat_id
|
|
WHERE cs.username = ?
|
|
AND cm.model_name IS NOT NULL
|
|
GROUP BY model_name
|
|
ORDER BY usage_count DESC
|
|
LIMIT 1
|
|
`),
|
|
getCollectedPersonaCount: db.prepare("SELECT COUNT(*) AS count FROM personas WHERE username = ? AND source_market_id IS NOT NULL"),
|
|
getPublishedPersonaUsage: db.prepare(`
|
|
SELECT COUNT(*) AS published_count, COALESCE(SUM(usage_count), 0) AS usage_total
|
|
FROM persona_market
|
|
WHERE creator_username = ?
|
|
AND soft_deleted_at IS NULL
|
|
`),
|
|
updateChatSessionsUsername: db.prepare("UPDATE chat_sessions SET username = ? WHERE username = ?"),
|
|
updatePersonasUsername: db.prepare("UPDATE personas SET username = ? WHERE username = ?"),
|
|
updatePersonasSourceCreator: db.prepare("UPDATE personas SET source_creator_username = ? WHERE source_creator_username = ?"),
|
|
updateUserSettingsUsername: db.prepare("UPDATE user_settings SET username = ? WHERE username = ?"),
|
|
updatePersonaMarketCreator: db.prepare("UPDATE persona_market SET creator_username = ? WHERE creator_username = ?"),
|
|
updatePersonaVersionsUsername: db.prepare("UPDATE persona_versions SET username = ? WHERE username = ?"),
|
|
updatePromptTemplatesUsername: db.prepare("UPDATE prompt_templates SET username = ? WHERE username = ?"),
|
|
updateChatMemoriesUsername: db.prepare("UPDATE chat_memories SET username = ? WHERE username = ?"),
|
|
updatePersonaChatStateUsername: db.prepare("UPDATE persona_chat_state SET username = ? WHERE username = ?"),
|
|
updateMarketFavoritesUsername: db.prepare("UPDATE persona_market_favorites SET username = ? WHERE username = ?"),
|
|
updateMarketRatingsUsername: db.prepare("UPDATE persona_market_ratings SET username = ? WHERE username = ?"),
|
|
updateMarketReportsUsername: db.prepare("UPDATE persona_market_reports SET reporter_username = ? WHERE reporter_username = ?"),
|
|
deleteChatMemoriesByUser: db.prepare("DELETE FROM chat_memories WHERE username = ?"),
|
|
deleteChatSessionsByUser: db.prepare("DELETE FROM chat_sessions WHERE username = ?"),
|
|
deletePersonasByUser: db.prepare("DELETE FROM personas WHERE username = ?"),
|
|
deleteUserSettingsByUser: db.prepare("DELETE FROM user_settings WHERE username = ?"),
|
|
deletePersonaVersionsByUser: db.prepare("DELETE FROM persona_versions WHERE username = ?"),
|
|
deletePromptTemplatesByUser: db.prepare("DELETE FROM prompt_templates WHERE username = ?"),
|
|
deleteMarketPersonasByCreator: db.prepare("DELETE FROM persona_market WHERE creator_username = ?"),
|
|
deleteMarketFavoritesByUser: db.prepare("DELETE FROM persona_market_favorites WHERE username = ?"),
|
|
deleteMarketRatingsByUser: db.prepare("DELETE FROM persona_market_ratings WHERE username = ?"),
|
|
deleteMarketReportsByUser: db.prepare("DELETE FROM persona_market_reports WHERE reporter_username = ?"),
|
|
deletePersonaChatStateByUser: db.prepare("DELETE FROM persona_chat_state WHERE username = ?"),
|
|
deleteUser: db.prepare("DELETE FROM users WHERE username = ?"),
|
|
deleteMarketPersonaByPersonaId: db.prepare("DELETE FROM persona_market WHERE persona_id = ? AND creator_username = ?"),
|
|
incrementMarketUsageCount: db.prepare("UPDATE persona_market SET usage_count = usage_count + 1 WHERE id = ?")
|
|
};
|
|
|
|
const renameUserTransaction = db.transaction((currentUsername, nextUsername) => {
|
|
statements.updateUsername.run(nextUsername, currentUsername);
|
|
statements.updateChatSessionsUsername.run(nextUsername, currentUsername);
|
|
statements.updatePersonasUsername.run(nextUsername, currentUsername);
|
|
statements.updatePersonasSourceCreator.run(nextUsername, currentUsername);
|
|
statements.updateUserSettingsUsername.run(nextUsername, currentUsername);
|
|
statements.updatePersonaMarketCreator.run(nextUsername, currentUsername);
|
|
statements.updatePersonaVersionsUsername.run(nextUsername, currentUsername);
|
|
statements.updatePromptTemplatesUsername.run(nextUsername, currentUsername);
|
|
statements.updateChatMemoriesUsername.run(nextUsername, currentUsername);
|
|
statements.updatePersonaChatStateUsername.run(nextUsername, currentUsername);
|
|
statements.updateMarketFavoritesUsername.run(nextUsername, currentUsername);
|
|
statements.updateMarketRatingsUsername.run(nextUsername, currentUsername);
|
|
statements.updateMarketReportsUsername.run(nextUsername, currentUsername);
|
|
});
|
|
|
|
const deleteUserTransaction = db.transaction((username) => {
|
|
statements.deleteMarketFavoritesByUser.run(username);
|
|
statements.deleteMarketRatingsByUser.run(username);
|
|
statements.deleteMarketReportsByUser.run(username);
|
|
statements.deleteMarketPersonasByCreator.run(username);
|
|
statements.deletePromptTemplatesByUser.run(username);
|
|
statements.deletePersonaVersionsByUser.run(username);
|
|
statements.deleteChatMemoriesByUser.run(username);
|
|
statements.deletePersonaChatStateByUser.run(username);
|
|
statements.deleteChatSessionsByUser.run(username);
|
|
statements.deleteUserSettingsByUser.run(username);
|
|
statements.deletePersonasByUser.run(username);
|
|
return statements.deleteUser.run(username);
|
|
});
|
|
|
|
const completeChatTurnTransaction = db.transaction((chatId, userMessageId, assistantContent, retryState, modelName) => {
|
|
const assistantResult = statements.insertChatMessage.run(
|
|
chatId,
|
|
"bot",
|
|
String(assistantContent || ""),
|
|
modelName || null,
|
|
JSON.stringify(retryState.retryVariants),
|
|
retryState.retryActiveIndex,
|
|
retryState.retryRetriesUsed,
|
|
retryState.retryPromptMessageId ?? null,
|
|
"complete",
|
|
null,
|
|
userMessageId
|
|
);
|
|
statements.updateChatMessageDelivery.run("complete", null, userMessageId, chatId);
|
|
statements.setChatActiveLeafById.run(assistantResult.lastInsertRowid, chatId);
|
|
return assistantResult;
|
|
});
|
|
|
|
const insertBranchChatMessageTransaction = db.transaction((chatId, role, content, retryState, modelName, deliveryStatus, errorMessage, parentMessageId) => {
|
|
const result = statements.insertChatMessage.run(
|
|
chatId, role, String(content || ""), modelName || null,
|
|
retryState ? JSON.stringify(retryState.retryVariants) : null,
|
|
retryState?.retryActiveIndex ?? 0,
|
|
retryState?.retryRetriesUsed ?? 0,
|
|
retryState?.retryPromptMessageId ?? null,
|
|
deliveryStatus,
|
|
errorMessage,
|
|
parentMessageId ?? null
|
|
);
|
|
statements.setChatActiveLeafById.run(result.lastInsertRowid, chatId);
|
|
return result;
|
|
});
|
|
|
|
const failChatTurnTransaction = db.transaction((chatId, userMessageId, errorMessage, parentMessageId) => {
|
|
statements.updateChatMessageDelivery.run("failed", errorMessage, userMessageId, chatId);
|
|
statements.setChatActiveLeafById.run(parentMessageId ?? null, chatId);
|
|
});
|
|
|
|
const savePersonaVersion = db.transaction((personaId, username) => {
|
|
const persona = statements.getPersona.get(personaId, username);
|
|
if (!persona) return null;
|
|
const versionNumber = statements.getNextPersonaVersionNumber.get(personaId).nextVersion;
|
|
statements.insertPersonaVersion.run(personaId, username, versionNumber, buildPersonaSnapshot(persona));
|
|
return versionNumber;
|
|
});
|
|
|
|
const clonePersonaTransaction = db.transaction((personaId, username) => {
|
|
const source = statements.getPersona.get(personaId, username);
|
|
if (!source) return null;
|
|
const cloneId = statements.insertPersona.run(
|
|
username,
|
|
`${source.name} Copy`,
|
|
source.pronouns,
|
|
source.appearance,
|
|
source.background,
|
|
source.details,
|
|
source.example_dialogues,
|
|
source.persona_type
|
|
).lastInsertRowid;
|
|
const clone = statements.getPersona.get(cloneId, username);
|
|
statements.insertPersonaVersion.run(cloneId, username, 1, buildPersonaSnapshot(clone));
|
|
return clone;
|
|
});
|
|
|
|
const importWorkspaceTransaction = db.transaction((username, workspace) => {
|
|
const imported = {personas: 0, chats: 0, templates: 0};
|
|
for (const persona of workspace.personas || []) {
|
|
const personaId = statements.insertPersona.run(
|
|
username,
|
|
persona.name,
|
|
persona.pronouns ?? null,
|
|
persona.appearance ?? null,
|
|
persona.background ?? null,
|
|
persona.details ?? null,
|
|
persona.example_dialogues ?? null,
|
|
persona.persona_type || "assistant"
|
|
).lastInsertRowid;
|
|
statements.insertPersonaVersion.run(personaId, username, 1, JSON.stringify(persona));
|
|
imported.personas += 1;
|
|
}
|
|
|
|
for (const template of workspace.templates || []) {
|
|
statements.insertPromptTemplate.run(
|
|
username,
|
|
null,
|
|
template.name,
|
|
template.description ?? null,
|
|
template.category ?? null,
|
|
template.prompt_text,
|
|
template.starter_text ?? null,
|
|
template.is_shared ? 1 : 0
|
|
);
|
|
imported.templates += 1;
|
|
}
|
|
|
|
for (const chat of workspace.chats || []) {
|
|
const chatId = statements.insertChatSession.run(
|
|
username,
|
|
chat.stored_title || chat.title || "Imported chat",
|
|
null,
|
|
null,
|
|
chat.folder_name ?? null,
|
|
chat.is_pinned ? 1 : 0,
|
|
chat.archived_at ?? null,
|
|
chat.scenario_prompt ?? null,
|
|
chat.scenario_summary ?? null
|
|
).lastInsertRowid;
|
|
const importedMessageIds = new Map();
|
|
for (const message of chat.messages || []) {
|
|
const mappedRetryPromptId = importedMessageIds.get(message.retryPromptMessageId) ?? null;
|
|
const mappedParentId = importedMessageIds.get(message.parentMessageId) ?? null;
|
|
const result = statements.insertChatMessage.run(
|
|
chatId,
|
|
message.role,
|
|
message.content,
|
|
message.model_name ?? null,
|
|
JSON.stringify(message.retryVariants || [message.content || ""]),
|
|
Number(message.retryActiveIndex || 0),
|
|
Number(message.retryRetriesUsed || 0),
|
|
mappedRetryPromptId,
|
|
message.deliveryStatus || "complete",
|
|
message.errorMessage || null,
|
|
mappedParentId
|
|
);
|
|
if (message.sourceId != null) importedMessageIds.set(message.sourceId, Number(result.lastInsertRowid));
|
|
}
|
|
statements.updateChatGenerationSettings.run(
|
|
chat.preferred_model ?? null,
|
|
chat.temperature ?? null,
|
|
chat.context_length ?? null,
|
|
chat.response_length ?? null,
|
|
chat.system_instruction ?? null,
|
|
chatId,
|
|
username
|
|
);
|
|
const importedActiveLeaf = importedMessageIds.get(chat.active_leaf_message_id)
|
|
?? Array.from(importedMessageIds.values()).at(-1)
|
|
?? null;
|
|
statements.setChatActiveLeafById.run(importedActiveLeaf, chatId);
|
|
if (chat.context_summary) {
|
|
const mappedSummaryMessageId = importedMessageIds.get(Number(chat.context_summary_message_id || 0)) || 0;
|
|
statements.updateChatContextSummary.run(
|
|
chat.context_summary,
|
|
mappedSummaryMessageId,
|
|
chatId,
|
|
username
|
|
);
|
|
}
|
|
for (const memory of chat.memories || []) {
|
|
const fact = String(memory?.fact || "").trim();
|
|
if (!fact) continue;
|
|
statements.insertChatMemory.run(username, chatId, null, null, fact);
|
|
}
|
|
const personaState = chat.persona_state || chat.personaChatState;
|
|
if (personaState) {
|
|
statements.upsertPersonaChatState.run(
|
|
username,
|
|
chatId,
|
|
null,
|
|
null,
|
|
personaState.relationship_notes ?? personaState.relationshipNotes ?? null,
|
|
personaState.tone ?? null,
|
|
personaState.current_location ?? personaState.currentLocation ?? null,
|
|
personaState.goals ?? null,
|
|
personaState.unresolved_threads ?? personaState.unresolvedThreads ?? null,
|
|
personaState.boundaries ?? null
|
|
);
|
|
}
|
|
imported.chats += 1;
|
|
}
|
|
|
|
return imported;
|
|
});
|
|
|
|
return {
|
|
getUser: (username) => statements.getUser.get(username),
|
|
insertUser: (username, passwordHash) => statements.insertUser.run(username, passwordHash),
|
|
updatePassword: (passwordHash, username) => statements.updatePassword.run(passwordHash, username),
|
|
incrementSessionVersion(username) {
|
|
statements.incrementSessionVersion.run(username);
|
|
return statements.getUser.get(username);
|
|
},
|
|
renameUser: (currentUsername, nextUsername) => renameUserTransaction(currentUsername, nextUsername),
|
|
deleteUser: (username) => deleteUserTransaction(username),
|
|
listChats: (username) => statements.listChatSessions.all(username),
|
|
searchChats(username, query) {
|
|
const like = `%${String(query || "").trim().toLowerCase()}%`;
|
|
return statements.searchChats.all(username, like, like);
|
|
},
|
|
countChats: (username) => statements.countChatSessions.get(username).count,
|
|
getChat: (chatId, username) => statements.getChatSession.get(chatId, username),
|
|
getChatByParticipants: (username, assistantPersonaId, userPersonaId) => statements.getChatSessionByParticipants.get(username, assistantPersonaId, userPersonaId, userPersonaId),
|
|
createChat(username, title, assistantPersonaId = null, userPersonaId = null, scenarioPrompt = null, scenarioSummary = null, organization = {}) {
|
|
const chatId = statements.insertChatSession.run(
|
|
username,
|
|
title,
|
|
assistantPersonaId,
|
|
userPersonaId,
|
|
organization.folderName ?? null,
|
|
organization.isPinned ? 1 : 0,
|
|
organization.archivedAt ?? null,
|
|
scenarioPrompt,
|
|
scenarioSummary
|
|
).lastInsertRowid;
|
|
return statements.getChatSession.get(chatId, username);
|
|
},
|
|
updateChatTitle: (chatId, username, title) => statements.updateChatSessionTitle.run(title, chatId, username),
|
|
updateChatScene: (chatId, username, scenarioPrompt, scenarioSummary) => statements.updateChatSessionScene.run(scenarioPrompt, scenarioSummary, chatId, username),
|
|
updateChatContextSummary: (chatId, username, summary, messageId) => statements.updateChatContextSummary.run(summary, Number(messageId || 0), chatId, username),
|
|
getPersonaChatState: (chatId, username) => statements.getPersonaChatState.get(chatId, username) || null,
|
|
updatePersonaChatState(username, chat, state) {
|
|
statements.upsertPersonaChatState.run(
|
|
username,
|
|
chat.id,
|
|
chat.assistant_persona_id ?? null,
|
|
chat.user_persona_id ?? null,
|
|
state.relationship_notes ?? null,
|
|
state.tone ?? null,
|
|
state.current_location ?? null,
|
|
state.goals ?? null,
|
|
state.unresolved_threads ?? null,
|
|
state.boundaries ?? null
|
|
);
|
|
return statements.getPersonaChatState.get(chat.id, username);
|
|
},
|
|
updateChatOrganization(chatId, username, {folderName = null, isPinned = false, archivedAt = null}) {
|
|
return statements.updateChatSessionOrganization.run(folderName, isPinned ? 1 : 0, archivedAt, chatId, username);
|
|
},
|
|
touchChat: (chatId, username) => statements.touchChatSession.run(chatId, username),
|
|
deleteChat: (chatId, username) => statements.deleteChatSession.run(chatId, username),
|
|
listChatMessages: (chatId) => statements.getChatMessages.all(chatId),
|
|
listActiveBranchMessages: (chatId) => statements.getActiveBranchMessages.all(chatId),
|
|
listSiblingChatMessages: (chatId, role, parentMessageId) => statements.getSiblingChatMessages.all(chatId, role, parentMessageId ?? null),
|
|
getLatestDescendantMessage: (chatId, messageId) => statements.getLatestDescendantMessage.get(chatId, messageId, chatId),
|
|
getRecentChatMessages: (chatId) => statements.getRecentChatMessages.all(chatId, config.chatHistoryLimit),
|
|
getRecentChatMessagesUpToId: (chatId, messageId) => statements.getRecentChatMessagesUpToId.all(chatId, messageId, config.chatHistoryLimit),
|
|
getChatMessage: (chatId, messageId) => statements.getChatMessageById.get(messageId, chatId),
|
|
getChatMessageByIndex: (chatId, index) => statements.getChatMessageByIndex.get(chatId, index),
|
|
getLatestChatMessage: (chatId) => statements.getLatestChatMessage.get(chatId),
|
|
getPreviousUserMessage: (chatId, messageId) => statements.getPreviousUserMessage.get(chatId, messageId),
|
|
listChatMemories: (chatId, username) => statements.listChatMemories.all(chatId, username),
|
|
getChatMemory: (chatId, memoryId, username) => statements.getChatMemory.get(memoryId, chatId, username),
|
|
createChatMemory(username, chat, fact) {
|
|
const result = statements.insertChatMemory.run(
|
|
username,
|
|
chat.id,
|
|
chat.assistant_persona_id ?? null,
|
|
chat.user_persona_id ?? null,
|
|
String(fact || "").trim()
|
|
);
|
|
return statements.getChatMemory.get(result.lastInsertRowid, chat.id, username);
|
|
},
|
|
updateChatMemory: (chatId, memoryId, username, fact) => statements.updateChatMemory.run(String(fact || "").trim(), memoryId, chatId, username),
|
|
deleteChatMemory: (chatId, memoryId, username) => statements.deleteChatMemory.run(memoryId, chatId, username),
|
|
insertChatMessage(chatId, role, content, retryState = null, modelName = null, deliveryStatus = "complete", errorMessage = null, parentMessageId = null) {
|
|
return statements.insertChatMessage.run(
|
|
chatId,
|
|
role,
|
|
String(content || ""),
|
|
modelName || null,
|
|
retryState ? JSON.stringify(retryState.retryVariants) : null,
|
|
retryState?.retryActiveIndex ?? 0,
|
|
retryState?.retryRetriesUsed ?? 0,
|
|
retryState?.retryPromptMessageId ?? null,
|
|
deliveryStatus,
|
|
errorMessage,
|
|
parentMessageId
|
|
);
|
|
},
|
|
insertBranchChatMessage: (chatId, role, content, retryState = null, modelName = null, deliveryStatus = "complete", errorMessage = null, parentMessageId = null) =>
|
|
insertBranchChatMessageTransaction(chatId, role, content, retryState, modelName, deliveryStatus, errorMessage, parentMessageId),
|
|
updateChatMessageDelivery: (chatId, messageId, deliveryStatus, errorMessage = null) =>
|
|
statements.updateChatMessageDelivery.run(deliveryStatus, errorMessage, messageId, chatId),
|
|
completeChatTurn: (chatId, userMessageId, assistantContent, retryState, modelName = null) =>
|
|
completeChatTurnTransaction(chatId, userMessageId, assistantContent, retryState, modelName),
|
|
failChatTurn: (chatId, userMessageId, errorMessage, parentMessageId = null) =>
|
|
failChatTurnTransaction(chatId, userMessageId, errorMessage, parentMessageId),
|
|
updateChatActiveLeaf: (chatId, username, messageId) => statements.updateChatActiveLeaf.run(messageId, chatId, username),
|
|
updateChatGenerationSettings: (chatId, username, settings) => statements.updateChatGenerationSettings.run(
|
|
settings.preferredModel ?? null,
|
|
settings.temperature ?? null,
|
|
settings.contextLength ?? null,
|
|
settings.responseLength ?? null,
|
|
settings.systemInstruction ?? null,
|
|
chatId,
|
|
username
|
|
),
|
|
updateChatMessage: (chatId, messageId, content) => statements.updateChatMessage.run(content, messageId, chatId),
|
|
updateChatMessageRetryState: (chatId, messageId, payload) => statements.updateChatMessageWithRetryState.run(
|
|
payload.content,
|
|
JSON.stringify(payload.retryVariants),
|
|
payload.retryActiveIndex,
|
|
payload.retryRetriesUsed,
|
|
payload.retryPromptMessageId ?? null,
|
|
messageId,
|
|
chatId
|
|
),
|
|
deleteChatMessage: (chatId, messageId) => statements.deleteChatMessage.run(messageId, chatId),
|
|
clearChatMessages: (chatId) => statements.deleteChatMessages.run(chatId),
|
|
listPersonasByType: (username, personaType) => statements.listPersonasByType.all(username, personaType),
|
|
listAllPersonas: (username) => statements.listAllPersonas.all(username),
|
|
getPersona: (personaId, username) => statements.getPersona.get(personaId, username),
|
|
createPersona(username, payload, personaType) {
|
|
const personaId = statements.insertPersona.run(
|
|
username,
|
|
payload.name,
|
|
payload.pronouns,
|
|
payload.appearance,
|
|
payload.background,
|
|
payload.details,
|
|
payload.exampleDialogues,
|
|
personaType
|
|
).lastInsertRowid;
|
|
const persona = statements.getPersona.get(personaId, username);
|
|
statements.insertPersonaVersion.run(personaId, username, 1, buildPersonaSnapshot(persona));
|
|
return persona;
|
|
},
|
|
updatePersona(personaId, username, payload) {
|
|
savePersonaVersion(personaId, username);
|
|
return statements.updatePersona.run(
|
|
payload.name,
|
|
payload.pronouns,
|
|
payload.appearance,
|
|
payload.background,
|
|
payload.details,
|
|
payload.exampleDialogues,
|
|
personaId,
|
|
username
|
|
);
|
|
},
|
|
restorePersonaVersion(personaId, versionId, username) {
|
|
const version = statements.getPersonaVersion.get(versionId, personaId, username);
|
|
if (!version) return null;
|
|
savePersonaVersion(personaId, username);
|
|
const snapshot = JSON.parse(version.snapshot_json);
|
|
statements.updatePersona.run(
|
|
snapshot.name,
|
|
snapshot.pronouns ?? null,
|
|
snapshot.appearance ?? null,
|
|
snapshot.background ?? null,
|
|
snapshot.details ?? null,
|
|
snapshot.example_dialogues ?? null,
|
|
personaId,
|
|
username
|
|
);
|
|
return statements.getPersona.get(personaId, username);
|
|
},
|
|
listPersonaVersions(personaId, username) {
|
|
return statements.listPersonaVersions.all(personaId, username).map((version) => ({
|
|
...version,
|
|
snapshot: JSON.parse(version.snapshot_json)
|
|
}));
|
|
},
|
|
clonePersona: (personaId, username) => clonePersonaTransaction(personaId, username),
|
|
deletePersona: (personaId, username) => statements.deletePersona.run(personaId, username),
|
|
clearPersonaReferences(username, personaId) {
|
|
statements.clearAssistantPersonaFromChats.run(username, personaId);
|
|
statements.clearUserPersonaFromChats.run(username, personaId);
|
|
statements.deleteMarketPersonaByPersonaId.run(personaId, username);
|
|
},
|
|
getActivePersonaIds: (username) => statements.getActivePersonaId.get(username) || {},
|
|
setActiveUserPersona: (username, personaId) => statements.setActiveUserPersona.run(username, personaId),
|
|
getActiveUserPersona: (username) => statements.getActiveUserPersona.get(username),
|
|
getAssistantPersonaForChat: (chatId, username) => statements.getAssistantPersonaForChat.get(chatId, username),
|
|
getUserPersonaForChat: (chatId, username) => statements.getUserPersonaForChat.get(chatId, username),
|
|
listMarketPersonas({admin = false, username = null, personaType = null, sort = "best"} = {}) {
|
|
const normalizedPersonaType = normalizeMarketPersonaType(personaType);
|
|
const normalizedSort = normalizeMarketSort(sort);
|
|
const params = [username];
|
|
const filters = [];
|
|
|
|
if (!admin) {
|
|
filters.push("pm.soft_deleted_at IS NULL");
|
|
filters.push("pm.moderation_status != 'rejected'");
|
|
}
|
|
|
|
if (normalizedPersonaType) {
|
|
filters.push("pm.persona_type = ?");
|
|
params.push(normalizedPersonaType);
|
|
}
|
|
|
|
const whereClause = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
|
|
const query = db.prepare(`
|
|
SELECT pm.id, pm.persona_id, pm.creator_username, pm.name, pm.pronouns, pm.appearance, pm.background, pm.details,
|
|
pm.example_dialogues, pm.persona_type, pm.tags, pm.usage_count, pm.favorite_count, pm.rating_total, pm.rating_count,
|
|
pm.moderation_status, pm.moderation_notes, pm.created_at, pm.updated_at, pm.soft_deleted_at,
|
|
CASE WHEN pm.rating_count > 0 THEN CAST(pm.rating_total AS REAL) / pm.rating_count ELSE 0 END AS rating_average,
|
|
CASE WHEN mf.username IS NULL THEN 0 ELSE 1 END AS is_favorite
|
|
FROM persona_market pm
|
|
LEFT JOIN persona_market_favorites mf ON mf.market_id = pm.id AND mf.username = ?
|
|
${whereClause}
|
|
ORDER BY ${MARKET_SORT_ORDERS[normalizedSort]}
|
|
`);
|
|
|
|
return query.all(...params).map((persona) => ({
|
|
...persona,
|
|
is_favorite: Boolean(persona.is_favorite),
|
|
tags: parseJsonArray(persona.tags)
|
|
}));
|
|
},
|
|
getMarketPersona: (marketId) => {
|
|
const persona = statements.getMarketPersona.get(marketId);
|
|
return persona ? {...persona, tags: parseJsonArray(persona.tags)} : null;
|
|
},
|
|
getMarketPersonaByPersonaId: (personaId, username) => {
|
|
const persona = statements.getMarketPersonaByPersonaId.get(personaId, username);
|
|
return persona ? {...persona, tags: parseJsonArray(persona.tags)} : null;
|
|
},
|
|
upsertMarketPersona(personaId, username, persona, tags = []) {
|
|
statements.upsertMarketPersona.run(
|
|
personaId,
|
|
username,
|
|
persona.name,
|
|
persona.pronouns,
|
|
persona.appearance,
|
|
persona.background,
|
|
persona.details,
|
|
persona.example_dialogues,
|
|
persona.persona_type,
|
|
JSON.stringify(tags)
|
|
);
|
|
return this.getMarketPersonaByPersonaId(personaId, username);
|
|
},
|
|
listPublishedPersonaIds: (username) => statements.listPublishedPersonaIds.all(username).map((row) => row.persona_id),
|
|
getPersonaBySourceMarket: (username, marketId) => statements.getPersonaBySourceMarket.get(username, marketId),
|
|
collectMarketPersona(username, marketPersona) {
|
|
const personaId = statements.insertMarketPersona.run(
|
|
username,
|
|
marketPersona.name,
|
|
marketPersona.pronouns,
|
|
marketPersona.appearance,
|
|
marketPersona.background,
|
|
marketPersona.details,
|
|
marketPersona.example_dialogues,
|
|
marketPersona.persona_type,
|
|
marketPersona.id,
|
|
marketPersona.creator_username
|
|
).lastInsertRowid;
|
|
const persona = statements.getPersona.get(personaId, username);
|
|
statements.insertPersonaVersion.run(personaId, username, 1, buildPersonaSnapshot(persona));
|
|
return persona;
|
|
},
|
|
incrementMarketUsageCount: (marketId) => statements.incrementMarketUsageCount.run(marketId),
|
|
toggleMarketFavorite(marketId, username) {
|
|
const favorite = statements.isMarketFavorite.get(marketId, username);
|
|
if (favorite) statements.deleteMarketFavorite.run(marketId, username);
|
|
else statements.insertMarketFavorite.run(marketId, username);
|
|
statements.recountMarketFavorites.run(marketId, marketId);
|
|
return !favorite;
|
|
},
|
|
rateMarketPersona(marketId, username, rating) {
|
|
statements.upsertMarketRating.run(marketId, username, rating);
|
|
statements.recountMarketRatings.run(marketId, marketId, marketId);
|
|
return this.getMarketPersona(marketId);
|
|
},
|
|
reportMarketPersona: (marketId, username, reason, details) => statements.insertMarketReport.run(marketId, username, reason, details),
|
|
listMarketReports: () => statements.listMarketReports.all(),
|
|
updateMarketReportStatus: (reportId, status) => statements.updateMarketReportStatus.run(status, reportId),
|
|
updateMarketModeration: (marketId, {status, notes = null, softDelete = false}) => statements.updateMarketModeration.run(status, notes, softDelete ? 1 : 0, marketId),
|
|
deletePublishedPersona: (personaId, username) => statements.deleteMarketPersonaByPersonaId.run(personaId, username),
|
|
createPromptTemplate(username, payload) {
|
|
const id = statements.insertPromptTemplate.run(
|
|
username,
|
|
payload.personaId ?? null,
|
|
payload.name,
|
|
payload.description ?? null,
|
|
payload.category ?? null,
|
|
payload.promptText,
|
|
payload.starterText ?? null,
|
|
payload.isShared ? 1 : 0
|
|
).lastInsertRowid;
|
|
return statements.getPromptTemplate.get(id);
|
|
},
|
|
updatePromptTemplate(templateId, username, payload) {
|
|
return statements.updatePromptTemplate.run(
|
|
payload.name,
|
|
payload.description ?? null,
|
|
payload.category ?? null,
|
|
payload.promptText,
|
|
payload.starterText ?? null,
|
|
payload.isShared ? 1 : 0,
|
|
templateId,
|
|
username,
|
|
username
|
|
);
|
|
},
|
|
deletePromptTemplate: (templateId, username) => statements.deletePromptTemplate.run(templateId, username),
|
|
listPromptTemplates: (username) => statements.listPromptTemplates.all(username),
|
|
listPromptTemplatesForPersona: (username, personaId = null) => statements.listPersonaPromptTemplates.all(personaId, username, username),
|
|
getPromptTemplate: (templateId) => statements.getPromptTemplate.get(templateId),
|
|
getDashboardSummary(username) {
|
|
const favoriteModel = statements.getFavoriteModel.get(username);
|
|
const publishedUsage = statements.getPublishedPersonaUsage.get(username);
|
|
return {
|
|
chats: statements.countChatSessions.get(username).count,
|
|
messages: statements.getChatMessageCountForUser.get(username).count,
|
|
personas: statements.getPersonaCountForUser.get(username).count,
|
|
published: statements.getPublishedPersonaCountForUser.get(username).count,
|
|
marketPersonas: statements.listMarketPersonas.all().length,
|
|
mostUsedPersonas: statements.getMostUsedPersonas.all(username),
|
|
averageChatLength: Number(statements.getAverageChatLength.get(username)?.average_length || 0),
|
|
favoriteModel: favoriteModel?.model_name || null,
|
|
recentActivity: statements.getRecentActivity.all(username),
|
|
collectedPersonaCount: statements.getCollectedPersonaCount.get(username).count,
|
|
publishedPersonaPerformance: {
|
|
publishedCount: publishedUsage.published_count,
|
|
totalUses: publishedUsage.usage_total
|
|
}
|
|
};
|
|
},
|
|
exportWorkspace(username) {
|
|
return {
|
|
exportedAt: new Date().toISOString(),
|
|
chats: this.listChats(username).map((chat) => ({
|
|
...chat,
|
|
memories: this.listChatMemories(chat.id, username),
|
|
persona_state: this.getPersonaChatState(chat.id, username),
|
|
messages: this.listChatMessages(chat.id).map((message) => ({
|
|
...message,
|
|
retryVariants: parseJsonArray(message.retry_variants)
|
|
}))
|
|
})),
|
|
personas: this.listAllPersonas(username),
|
|
templates: this.listPromptTemplates(username)
|
|
};
|
|
},
|
|
importWorkspace: (username, workspace) => importWorkspaceTransaction(username, workspace)
|
|
};
|
|
}
|