chainlesschain 0.37.8 → 0.37.10

package/src/lib/plugin-manager.js

@@ -0,0 +1,312 @@
+/**
+ * Plugin Manager — Plugin installation, management, and marketplace for CLI.
+ * Manages plugin lifecycle: install, enable, disable, remove, update.
+ */
+
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+/**
+ * Ensure plugin tables exist.
+ */
+export function ensurePluginTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plugins (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      version TEXT NOT NULL,
+      description TEXT,
+      author TEXT,
+      homepage TEXT,
+      entry_point TEXT,
+      permissions TEXT,
+      status TEXT DEFAULT 'installed',
+      enabled INTEGER DEFAULT 1,
+      install_path TEXT,
+      installed_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plugin_settings (
+      id TEXT PRIMARY KEY,
+      plugin_id TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plugin_registry (
+      name TEXT PRIMARY KEY,
+      latest_version TEXT,
+      description TEXT,
+      author TEXT,
+      downloads INTEGER DEFAULT 0,
+      rating REAL DEFAULT 0,
+      tags TEXT,
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/**
+ * Install a plugin (record in DB).
+ */
+export function installPlugin(db, pluginInfo) {
+  ensurePluginTables(db);
+  const {
+    name,
+    version,
+    description,
+    author,
+    homepage,
+    entryPoint,
+    permissions,
+    installPath,
+  } = pluginInfo;
+
+  if (!name || !version) {
+    throw new Error("Plugin name and version are required");
+  }
+
+  // Check if already installed
+  const existing = getPlugin(db, name);
+  if (existing) {
+    throw new Error(`Plugin already installed: ${name}`);
+  }
+
+  const id = `plugin-${crypto.randomBytes(8).toString("hex")}`;
+
+  db.prepare(
+    `INSERT INTO plugins (id, name, version, description, author, homepage, entry_point, permissions, status, enabled, install_path)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    name,
+    version,
+    description || null,
+    author || null,
+    homepage || null,
+    entryPoint || null,
+    permissions ? JSON.stringify(permissions) : null,
+    "installed",
+    1,
+    installPath || null,
+  );
+
+  return {
+    id,
+    name,
+    version,
+    description,
+    author,
+    status: "installed",
+    enabled: true,
+  };
+}
+
+/**
+ * Get a plugin by name.
+ */
+export function getPlugin(db, name) {
+  ensurePluginTables(db);
+  return db.prepare("SELECT * FROM plugins WHERE name = ?").get(name);
+}
+
+/**
+ * Get a plugin by ID.
+ */
+export function getPluginById(db, pluginId) {
+  ensurePluginTables(db);
+  return db.prepare("SELECT * FROM plugins WHERE id = ?").get(pluginId);
+}
+
+/**
+ * List all installed plugins.
+ */
+export function listPlugins(db, options = {}) {
+  ensurePluginTables(db);
+  const { enabledOnly = false } = options;
+
+  if (enabledOnly) {
+    return db
+      .prepare("SELECT * FROM plugins WHERE enabled = 1 ORDER BY name ASC")
+      .all();
+  }
+  return db.prepare("SELECT * FROM plugins ORDER BY name ASC").all();
+}
+
+/**
+ * Enable a plugin.
+ */
+export function enablePlugin(db, name) {
+  ensurePluginTables(db);
+  const result = db
+    .prepare("UPDATE plugins SET enabled = ?, status = ? WHERE name = ?")
+    .run(1, "installed", name);
+  return result.changes > 0;
+}
+
+/**
+ * Disable a plugin.
+ */
+export function disablePlugin(db, name) {
+  ensurePluginTables(db);
+  const result = db
+    .prepare("UPDATE plugins SET enabled = ?, status = ? WHERE name = ?")
+    .run(0, "disabled", name);
+  return result.changes > 0;
+}
+
+/**
+ * Remove (uninstall) a plugin.
+ */
+export function removePlugin(db, name) {
+  ensurePluginTables(db);
+  // Remove settings first
+  const plugin = getPlugin(db, name);
+  if (!plugin) return false;
+
+  db.prepare("DELETE FROM plugin_settings WHERE plugin_id = ?").run(plugin.id);
+  const result = db.prepare("DELETE FROM plugins WHERE name = ?").run(name);
+  return result.changes > 0;
+}
+
+/**
+ * Update a plugin version.
+ */
+export function updatePlugin(db, name, newVersion) {
+  ensurePluginTables(db);
+  const result = db
+    .prepare(
+      "UPDATE plugins SET version = ?, updated_at = datetime('now') WHERE name = ?",
+    )
+    .run(newVersion, name);
+  return result.changes > 0;
+}
+
+/**
+ * Set a plugin setting.
+ */
+export function setPluginSetting(db, pluginName, key, value) {
+  ensurePluginTables(db);
+  const plugin = getPlugin(db, pluginName);
+  if (!plugin) throw new Error(`Plugin not found: ${pluginName}`);
+
+  // Remove existing setting for this key
+  db.prepare("DELETE FROM plugin_settings WHERE plugin_id = ? AND key = ?").run(
+    plugin.id,
+    key,
+  );
+  const settingId = `ps-${crypto.randomBytes(4).toString("hex")}`;
+  db.prepare(
+    `INSERT INTO plugin_settings (id, plugin_id, key, value) VALUES (?, ?, ?, ?)`,
+  ).run(
+    settingId,
+    plugin.id,
+    key,
+    typeof value === "string" ? value : JSON.stringify(value),
+  );
+
+  return true;
+}
+
+/**
+ * Get a plugin setting.
+ */
+export function getPluginSetting(db, pluginName, key) {
+  ensurePluginTables(db);
+  const plugin = getPlugin(db, pluginName);
+  if (!plugin) return null;
+
+  const row = db
+    .prepare(
+      "SELECT value FROM plugin_settings WHERE plugin_id = ? AND key = ?",
+    )
+    .get(plugin.id, key);
+  return row ? row.value : null;
+}
+
+/**
+ * Get all settings for a plugin.
+ */
+export function getPluginSettings(db, pluginName) {
+  ensurePluginTables(db);
+  const plugin = getPlugin(db, pluginName);
+  if (!plugin) return {};
+
+  const rows = db
+    .prepare("SELECT key, value FROM plugin_settings WHERE plugin_id = ?")
+    .all(plugin.id);
+  const settings = {};
+  for (const row of rows) {
+    settings[row.key] = row.value;
+  }
+  return settings;
+}
+
+// ─── Registry / Marketplace ─────────────────────────────
+
+/**
+ * Add/update a plugin in the registry.
+ */
+export function registerInMarketplace(db, pluginInfo) {
+  ensurePluginTables(db);
+  const { name, latestVersion, description, author, tags } = pluginInfo;
+
+  db.prepare(
+    `INSERT OR REPLACE INTO plugin_registry (name, latest_version, description, author, tags)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(
+    name,
+    latestVersion,
+    description || null,
+    author || null,
+    tags ? JSON.stringify(tags) : null,
+  );
+
+  return { name, latestVersion, description, author };
+}
+
+/**
+ * Search plugins in registry.
+ */
+export function searchRegistry(db, query) {
+  ensurePluginTables(db);
+  return db
+    .prepare(
+      "SELECT * FROM plugin_registry WHERE name LIKE ? OR description LIKE ? ORDER BY downloads DESC",
+    )
+    .all(`%${query}%`, `%${query}%`);
+}
+
+/**
+ * List all registry plugins.
+ */
+export function listRegistry(db) {
+  ensurePluginTables(db);
+  return db
+    .prepare("SELECT * FROM plugin_registry ORDER BY downloads DESC")
+    .all();
+}
+
+/**
+ * Get plugin summary.
+ */
+export function getPluginSummary(db) {
+  ensurePluginTables(db);
+  const total = db.prepare("SELECT COUNT(*) as c FROM plugins").get();
+  const enabled = db
+    .prepare("SELECT COUNT(*) as c FROM plugins WHERE enabled = ?")
+    .get(1);
+  const registry = db
+    .prepare("SELECT COUNT(*) as c FROM plugin_registry")
+    .get();
+
+  return {
+    installed: total?.c || 0,
+    enabled: enabled?.c || 0,
+    registryCount: registry?.c || 0,
+  };
+}

package/src/lib/response-cache.js

@@ -0,0 +1,156 @@
+/**
+ * Response cache for CLI
+ *
+ * Caches LLM responses to avoid redundant API calls.
+ * Lightweight port of desktop-app-vue/src/main/llm/response-cache.js
+ */
+
+import { createHash } from "crypto";
+
+const DEFAULT_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days
+const DEFAULT_MAX_SIZE = 500;
+
+function ensureCacheTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS llm_cache (
+      cache_key TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      request_hash TEXT NOT NULL,
+      response_content TEXT NOT NULL,
+      response_tokens INTEGER DEFAULT 0,
+      hit_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      last_accessed_at TEXT DEFAULT (datetime('now')),
+      expires_at TEXT NOT NULL
+    )
+  `);
+}
+
+/**
+ * Generate a cache key from request parameters
+ */
+function generateCacheKey(provider, model, messages) {
+  const payload = JSON.stringify({ provider, model, messages });
+  return createHash("sha256").update(payload).digest("hex");
+}
+
+/**
+ * Look up a cached response
+ * @returns {{ hit: boolean, response?: string, tokensSaved?: number, cacheAge?: number }}
+ */
+export function getCachedResponse(db, provider, model, messages) {
+  ensureCacheTable(db);
+
+  const key = generateCacheKey(provider, model, messages);
+
+  const row = db
+    .prepare(
+      `SELECT * FROM llm_cache WHERE cache_key = ? AND expires_at > datetime('now')`,
+    )
+    .get(key);
+
+  if (!row) {
+    return { hit: false };
+  }
+
+  // Update access stats
+  db.prepare(
+    `UPDATE llm_cache SET hit_count = hit_count + 1, last_accessed_at = datetime('now') WHERE cache_key = ?`,
+  ).run(key);
+
+  return {
+    hit: true,
+    response: row.response_content,
+    tokensSaved: row.response_tokens,
+    cacheAge: Date.now() - new Date(row.created_at).getTime(),
+  };
+}
+
+/**
+ * Store a response in cache
+ */
+export function setCachedResponse(
+  db,
+  provider,
+  model,
+  messages,
+  response,
+  options = {},
+) {
+  ensureCacheTable(db);
+
+  const key = generateCacheKey(provider, model, messages);
+  const requestHash = createHash("md5")
+    .update(JSON.stringify(messages))
+    .digest("hex");
+  const ttl = options.ttl || DEFAULT_TTL;
+  const maxSize = options.maxSize || DEFAULT_MAX_SIZE;
+  const expiresAt = new Date(Date.now() + ttl).toISOString();
+  const responseTokens = options.responseTokens || 0;
+
+  // LRU eviction if needed
+  const countRow = db.prepare("SELECT COUNT(*) as cnt FROM llm_cache").get();
+  const count = countRow?.cnt || 0;
+  if (count >= maxSize) {
+    db.prepare(
+      `DELETE FROM llm_cache WHERE cache_key IN (
+        SELECT cache_key FROM llm_cache ORDER BY last_accessed_at ASC, created_at ASC LIMIT ?
+      )`,
+    ).run(Math.max(1, Math.ceil(maxSize * 0.1)));
+  }
+
+  db.prepare(
+    `INSERT OR REPLACE INTO llm_cache (cache_key, provider, model, request_hash, response_content, response_tokens, expires_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(key, provider, model, requestHash, response, responseTokens, expiresAt);
+}
+
+/**
+ * Clear all cached responses
+ */
+export function clearCache(db) {
+  ensureCacheTable(db);
+  db.prepare("DELETE FROM llm_cache").run();
+}
+
+/**
+ * Remove expired entries
+ */
+export function clearExpired(db) {
+  ensureCacheTable(db);
+  const result = db
+    .prepare("DELETE FROM llm_cache WHERE expires_at <= datetime('now')")
+    .run();
+  return result.changes;
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats(db) {
+  ensureCacheTable(db);
+
+  const stats = db
+    .prepare(
+      `SELECT
+        COUNT(*) as total_entries,
+        COALESCE(SUM(hit_count), 0) as total_hits,
+        COALESCE(SUM(response_tokens), 0) as total_tokens_saved
+      FROM llm_cache`,
+    )
+    .get();
+
+  const expired = db
+    .prepare(
+      "SELECT COUNT(*) as cnt FROM llm_cache WHERE expires_at <= datetime('now')",
+    )
+    .get();
+
+  return {
+    total_entries: stats?.total_entries || 0,
+    total_hits: stats?.total_hits || 0,
+    total_tokens_saved: stats?.total_tokens_saved || 0,
+    expired_entries: expired?.cnt || 0,
+  };
+}

package/src/lib/session-manager.js

@@ -0,0 +1,189 @@
+/**
+ * Session manager for CLI
+ *
+ * Persists chat/agent conversations to DB for resume and export.
+ * Lightweight port of desktop-app-vue/src/main/llm/session-manager.js
+ */
+
+import { createHash } from "crypto";
+
+function ensureSessionsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS llm_sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT DEFAULT 'Untitled',
+      provider TEXT DEFAULT '',
+      model TEXT DEFAULT '',
+      message_count INTEGER DEFAULT 0,
+      messages TEXT DEFAULT '[]',
+      summary TEXT DEFAULT '',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/**
+ * Create a new session
+ */
+export function createSession(db, options = {}) {
+  ensureSessionsTable(db);
+
+  const id =
+    options.id ||
+    `session-${Date.now()}-${createHash("sha256").update(Math.random().toString()).digest("hex").slice(0, 6)}`;
+
+  db.prepare(
+    `INSERT INTO llm_sessions (id, title, provider, model, messages) VALUES (?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    options.title || "Untitled",
+    options.provider || "",
+    options.model || "",
+    JSON.stringify(options.messages || []),
+  );
+
+  return { id, title: options.title || "Untitled" };
+}
+
+/**
+ * Add a message to a session
+ */
+export function addMessage(db, sessionId, role, content) {
+  ensureSessionsTable(db);
+
+  const session = db
+    .prepare("SELECT messages, message_count FROM llm_sessions WHERE id = ?")
+    .get(sessionId);
+
+  if (!session) return null;
+
+  const messages = JSON.parse(session.messages || "[]");
+  messages.push({ role, content, timestamp: new Date().toISOString() });
+
+  db.prepare(
+    `UPDATE llm_sessions SET messages = ?, message_count = ?, updated_at = datetime('now') WHERE id = ?`,
+  ).run(JSON.stringify(messages), messages.length, sessionId);
+
+  return { messageCount: messages.length };
+}
+
+/**
+ * Save all messages at once (batch update)
+ */
+export function saveMessages(db, sessionId, messages) {
+  ensureSessionsTable(db);
+
+  const result = db
+    .prepare(
+      `UPDATE llm_sessions SET messages = ?, message_count = ?, updated_at = datetime('now') WHERE id = ?`,
+    )
+    .run(JSON.stringify(messages), messages.length, sessionId);
+
+  return { messageCount: messages.length, updated: result.changes > 0 };
+}
+
+/**
+ * Get a session by ID
+ */
+export function getSession(db, sessionId) {
+  ensureSessionsTable(db);
+
+  // Try exact match first, then prefix match
+  let session = db
+    .prepare("SELECT * FROM llm_sessions WHERE id = ?")
+    .get(sessionId);
+
+  if (!session) {
+    session = db
+      .prepare("SELECT * FROM llm_sessions WHERE id LIKE ? LIMIT 1")
+      .get(`${sessionId}%`);
+  }
+
+  if (!session) return null;
+
+  return {
+    ...session,
+    messages: JSON.parse(session.messages || "[]"),
+  };
+}
+
+/**
+ * List all sessions
+ */
+export function listSessions(db, options = {}) {
+  ensureSessionsTable(db);
+
+  const limit = options.limit || 20;
+
+  return db
+    .prepare(
+      `SELECT id, title, provider, model, message_count, summary, created_at, updated_at
+       FROM llm_sessions
+       ORDER BY updated_at DESC
+       LIMIT ?`,
+    )
+    .all(limit);
+}
+
+/**
+ * Update session title or summary
+ */
+export function updateSession(db, sessionId, updates) {
+  ensureSessionsTable(db);
+
+  if (updates.title) {
+    db.prepare(
+      "UPDATE llm_sessions SET title = ?, updated_at = datetime('now') WHERE id = ?",
+    ).run(updates.title, sessionId);
+  }
+  if (updates.summary) {
+    db.prepare(
+      "UPDATE llm_sessions SET summary = ?, updated_at = datetime('now') WHERE id = ?",
+    ).run(updates.summary, sessionId);
+  }
+}
+
+/**
+ * Delete a session
+ */
+export function deleteSession(db, sessionId) {
+  ensureSessionsTable(db);
+  const result = db
+    .prepare("DELETE FROM llm_sessions WHERE id = ?")
+    .run(sessionId);
+  return result.changes > 0;
+}
+
+/**
+ * Export session as markdown
+ */
+export function exportSessionMarkdown(session) {
+  const lines = [
+    `# ${session.title}`,
+    "",
+    `- **Created**: ${session.created_at}`,
+    `- **Provider**: ${session.provider || "unknown"}`,
+    `- **Model**: ${session.model || "unknown"}`,
+    `- **Messages**: ${session.message_count}`,
+    "",
+    "---",
+    "",
+  ];
+
+  const messages =
+    typeof session.messages === "string"
+      ? JSON.parse(session.messages)
+      : session.messages || [];
+
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+    const label = msg.role === "user" ? "**You**" : "**AI**";
+    lines.push(`### ${label}`);
+    lines.push("");
+    lines.push(msg.content || "");
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}