chainlesschain 0.37.9 → 0.37.11

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");
+}

package/src/lib/skill-loader.js

@@ -0,0 +1,274 @@
+/**
+ * Multi-layer skill loader for CLI
+ *
+ * 4-layer priority system (highest wins on name collision):
+ *   0 (lowest)  bundled     — desktop-app-vue/.../skills/builtin/
+ *   1           marketplace — <userData>/marketplace/skills/
+ *   2           managed     — <userData>/skills/
+ *   3 (highest) workspace   — <projectRoot>/.chainlesschain/skills/
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getElectronUserDataDir } from "./paths.js";
+import { findProjectRoot } from "./project-detector.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Layer names in priority order (lowest → highest) */
+export const LAYER_NAMES = ["bundled", "marketplace", "managed", "workspace"];
+
+/**
+ * Simple YAML frontmatter parser (no dependencies)
+ * Shared utility extracted from skill.js
+ */
+export function parseSkillMd(content) {
+  const lines = content.split("\n");
+  if (lines[0].trim() !== "---") return { data: {}, body: content };
+
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+
+  if (endIndex === -1) return { data: {}, body: content };
+
+  const yamlLines = lines.slice(1, endIndex);
+  const body = lines
+    .slice(endIndex + 1)
+    .join("\n")
+    .trim();
+  const data = {};
+
+  let currentKey = null;
+  let currentArray = null;
+
+  for (const line of yamlLines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("- ")) {
+      const value = trimmed
+        .slice(2)
+        .trim()
+        .replace(/^['"]|['"]$/g, "");
+      if (currentArray) currentArray.push(value);
+      continue;
+    }
+
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      let value = trimmed.slice(colonIndex + 1).trim();
+
+      // Convert kebab-case to camelCase
+      const camelKey = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+
+      if (value === "") {
+        currentKey = camelKey;
+        currentArray = null;
+        continue;
+      }
+
+      // Handle inline arrays [a, b, c]
+      if (value.startsWith("[") && value.endsWith("]")) {
+        data[camelKey] = value
+          .slice(1, -1)
+          .split(",")
+          .map((v) => v.trim().replace(/^['"]|['"]$/g, ""))
+          .filter(Boolean);
+        currentArray = null;
+        currentKey = null;
+        continue;
+      }
+
+      // Handle booleans and numbers
+      if (value === "true") value = true;
+      else if (value === "false") value = false;
+      else if (value === "null") value = null;
+      else if (/^\d+(\.\d+)?$/.test(value)) value = parseFloat(value);
+      else value = value.replace(/^['"]|['"]$/g, "");
+
+      data[camelKey] = value;
+
+      if (Array.isArray(data[camelKey])) {
+        currentArray = data[camelKey];
+      } else {
+        currentArray = null;
+      }
+      currentKey = camelKey;
+    }
+  }
+
+  return { data, body };
+}
+
+/**
+ * Multi-layer CLI skill loader
+ */
+export class CLISkillLoader {
+  constructor() {
+    this._cache = null;
+  }
+
+  /**
+   * Get paths for each layer
+   * @returns {{ layer: string, path: string, exists: boolean }[]}
+   */
+  getLayerPaths() {
+    const layers = [];
+
+    // Layer 0: bundled — desktop-app-vue builtin skills
+    const bundledCandidates = [
+      path.resolve(
+        __dirname,
+        "../../../../desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
+      ),
+      path.resolve(
+        process.cwd(),
+        "desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
+      ),
+    ];
+    let bundledPath = null;
+    for (const c of bundledCandidates) {
+      if (fs.existsSync(c)) {
+        bundledPath = c;
+        break;
+      }
+    }
+    layers.push({
+      layer: "bundled",
+      path: bundledPath || bundledCandidates[0],
+      exists: bundledPath !== null,
+    });
+
+    // Layer 1: marketplace — <userData>/marketplace/skills/
+    const userData = getElectronUserDataDir();
+    const marketplacePath = path.join(userData, "marketplace", "skills");
+    layers.push({
+      layer: "marketplace",
+      path: marketplacePath,
+      exists: fs.existsSync(marketplacePath),
+    });
+
+    // Layer 2: managed — <userData>/skills/
+    const managedPath = path.join(userData, "skills");
+    layers.push({
+      layer: "managed",
+      path: managedPath,
+      exists: fs.existsSync(managedPath),
+    });
+
+    // Layer 3: workspace — <projectRoot>/.chainlesschain/skills/
+    const projectRoot = findProjectRoot();
+    if (projectRoot) {
+      const workspacePath = path.join(projectRoot, ".chainlesschain", "skills");
+      layers.push({
+        layer: "workspace",
+        path: workspacePath,
+        exists: fs.existsSync(workspacePath),
+      });
+    } else {
+      layers.push({
+        layer: "workspace",
+        path: null,
+        exists: false,
+      });
+    }
+
+    return layers;
+  }
+
+  /**
+   * Load skills from a single directory
+   * @param {string} dir - Directory to scan
+   * @param {string} layer - Layer name for source tracking
+   * @returns {object[]} Array of skill metadata
+   */
+  _loadFromDir(dir, layer) {
+    const skills = [];
+    if (!dir || !fs.existsSync(dir)) return skills;
+
+    try {
+      const dirs = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of dirs) {
+        if (!entry.isDirectory()) continue;
+
+        const skillMd = path.join(dir, entry.name, "SKILL.md");
+        if (!fs.existsSync(skillMd)) continue;
+
+        try {
+          const content = fs.readFileSync(skillMd, "utf-8");
+          const { data, body } = parseSkillMd(content);
+
+          skills.push({
+            id: data.name || entry.name,
+            displayName: data.displayName || entry.name,
+            description: data.description || "",
+            version: data.version || "1.0.0",
+            category: data.category || "uncategorized",
+            tags: data.tags || [],
+            userInvocable: data.userInvocable !== false,
+            handler: data.handler || null,
+            capabilities: data.capabilities || [],
+            os: data.os || [],
+            dirName: entry.name,
+            hasHandler: fs.existsSync(path.join(dir, entry.name, "handler.js")),
+            body,
+            source: layer,
+            skillDir: path.join(dir, entry.name),
+          });
+        } catch {
+          // Skip malformed skill files
+        }
+      }
+    } catch {
+      // Directory unreadable
+    }
+
+    return skills;
+  }
+
+  /**
+   * Load all skills from all layers, applying priority override
+   * Higher-priority layers override same-name skills from lower layers.
+   * @returns {object[]} Resolved skill list
+   */
+  loadAll() {
+    const layers = this.getLayerPaths();
+    const skillMap = new Map();
+
+    // Process in priority order (lowest first, so higher layers overwrite)
+    for (const { layer, path: layerPath, exists } of layers) {
+      if (!exists) continue;
+      const skills = this._loadFromDir(layerPath, layer);
+      for (const skill of skills) {
+        skillMap.set(skill.id, skill);
+      }
+    }
+
+    this._cache = Array.from(skillMap.values());
+    return this._cache;
+  }
+
+  /**
+   * Get resolved skills (uses cache if available)
+   * @returns {object[]}
+   */
+  getResolvedSkills() {
+    if (this._cache) return this._cache;
+    return this.loadAll();
+  }
+
+  /**
+   * Clear the cache
+   */
+  clearCache() {
+    this._cache = null;
+  }
+}