mcard-js 2.1.47 → 2.1.49

package/dist/chunk-OAHWTOEB.js

@@ -0,0 +1,275 @@
+import {
+  createPage
+} from "./chunk-3EIBJPNF.js";
+import {
+  init_Handle,
+  validateHandle
+} from "./chunk-ADV52544.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  INDEXEDDB_DEFAULT_DB_NAME,
+  INDEXEDDB_DEFAULT_DB_VERSION
+} from "./chunk-J3IDWMDN.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+
+// src/storage/engines/IndexedDBEngine.ts
+import { openDB } from "idb";
+init_Handle();
+var IndexedDBEngine = class {
+  db = null;
+  dbName;
+  constructor(dbName = INDEXEDDB_DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  /**
+   * Initialize the database connection
+   */
+  async init() {
+    this.db = await openDB(this.dbName, INDEXEDDB_DEFAULT_DB_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains("cards")) {
+          db.createObjectStore("cards", { keyPath: "hash" });
+        }
+        if (!db.objectStoreNames.contains("handles")) {
+          const handleStore = db.createObjectStore("handles", { keyPath: "handle" });
+          handleStore.createIndex("by-hash", "currentHash");
+        }
+        if (!db.objectStoreNames.contains("handleHistory")) {
+          const historyStore = db.createObjectStore("handleHistory", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          historyStore.createIndex("by-handle", "handle");
+        }
+      }
+    });
+  }
+  ensureDb() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call init() first.");
+    }
+    return this.db;
+  }
+  // =========== Card Operations ===========
+  async add(card) {
+    const db = this.ensureDb();
+    await db.put("cards", {
+      hash: card.hash,
+      content: card.content,
+      g_time: card.g_time
+    });
+    return card.hash;
+  }
+  async get(hash) {
+    const db = this.ensureDb();
+    const record = await db.get("cards", hash);
+    if (!record) return null;
+    return MCard.fromData(record.content, record.hash, record.g_time);
+  }
+  async delete(hash) {
+    const db = this.ensureDb();
+    await db.delete("cards", hash);
+  }
+  async getPage(pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const totalItems = await db.count("cards");
+    const allCards = await db.getAll("cards");
+    const start = (pageNumber - 1) * pageSize;
+    const pageRecords = allCards.slice(start, start + pageSize);
+    const items = pageRecords.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  async count() {
+    const db = this.ensureDb();
+    return db.count("cards");
+  }
+  async searchByHash(hashPrefix) {
+    const db = this.ensureDb();
+    const start = hashPrefix;
+    const end = hashPrefix + "\uFFFF";
+    const range = IDBKeyRange.bound(start, end);
+    const records = await db.getAll("cards", range);
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async search(query, pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    const decoder = new TextDecoder();
+    const filtered = records.filter((r) => {
+      try {
+        const text = decoder.decode(r.content);
+        return text.includes(query);
+      } catch {
+        return false;
+      }
+    });
+    const totalItems = filtered.length;
+    const start = (pageNumber - 1) * pageSize;
+    const pageItems = filtered.slice(start, start + pageSize).map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(pageItems, totalItems, pageNumber, pageSize);
+  }
+  async getAll() {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async clear() {
+    const db = this.ensureDb();
+    await db.clear("cards");
+    await db.clear("handles");
+    await db.clear("handleHistory");
+  }
+  // =========== Handle Operations ===========
+  async registerHandle(handle, hash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (existing) {
+      throw new Error(`Handle '${handle}' already exists.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.put("handles", {
+      handle: normalized,
+      currentHash: hash,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  async resolveHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const record = await db.get("handles", normalized);
+    return record?.currentHash ?? null;
+  }
+  async getByHandle(handle) {
+    const hash = await this.resolveHandle(handle);
+    if (!hash) return null;
+    return this.get(hash);
+  }
+  async updateHandle(handle, newHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (!existing) {
+      throw new Error(`Handle '${handle}' not found.`);
+    }
+    const previousHash = existing.currentHash;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.add("handleHistory", {
+      handle: normalized,
+      previousHash,
+      changedAt: now
+    });
+    await db.put("handles", {
+      ...existing,
+      currentHash: newHash,
+      updatedAt: now
+    });
+    return previousHash;
+  }
+  async getHandleHistory(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    return records.map((r) => ({ previousHash: r.previousHash, changedAt: r.changedAt })).reverse();
+  }
+  async pruneHandleHistory(handle, options = {}) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    let toDelete;
+    if (options.deleteAll) {
+      toDelete = records;
+    } else if (options.olderThan) {
+      toDelete = records.filter((r) => r.changedAt < options.olderThan);
+    } else {
+      return 0;
+    }
+    const tx = db.transaction("handleHistory", "readwrite");
+    for (const record of toDelete) {
+      await tx.store.delete(record.id);
+    }
+    await tx.done;
+    return toDelete.length;
+  }
+  // =========== Handle Management Operations ===========
+  async getAllHandles() {
+    const db = this.ensureDb();
+    const records = await db.getAll("handles");
+    return records.map((r) => ({ handle: r.handle, hash: r.currentHash }));
+  }
+  async removeHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const keysToTry = normalized !== handle.trim() ? [normalized, handle.trim()] : [normalized];
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    for (const key of keysToTry) {
+      await handleStore.delete(key);
+    }
+    const historyIndex = historyStore.index("by-handle");
+    for (const key of keysToTry) {
+      let cursor = await historyIndex.openCursor(key);
+      while (cursor) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+      }
+    }
+    await tx.done;
+  }
+  async renameHandle(oldHandle, newHandle) {
+    const db = this.ensureDb();
+    const normalizedOld = validateHandle(oldHandle);
+    const normalizedNew = validateHandle(newHandle);
+    if (normalizedOld === normalizedNew) return;
+    const oldEntry = await db.get("handles", normalizedOld);
+    if (!oldEntry) throw new Error(`Handle '${oldHandle}' not found.`);
+    const newEntry = await db.get("handles", normalizedNew);
+    if (newEntry) throw new Error(`Handle '${newHandle}' already exists.`);
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await handleStore.put({
+      ...oldEntry,
+      handle: normalizedNew,
+      updatedAt: now
+    });
+    await handleStore.delete(normalizedOld);
+    const historyIndex = historyStore.index("by-handle");
+    let cursor = await historyIndex.openCursor(normalizedOld);
+    while (cursor) {
+      const record = cursor.value;
+      record.handle = normalizedNew;
+      await cursor.update(record);
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  }
+  async deleteHistoryEntry(handle, previousHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    const entries = records.sort((a, b) => a.id - b.id);
+    const targetIdx = entries.findIndex((e) => e.previousHash === previousHash);
+    if (targetIdx === -1) return;
+    const target = entries[targetIdx];
+    const successor = entries[targetIdx + 1];
+    const tx = db.transaction("handleHistory", "readwrite");
+    const store = tx.objectStore("handleHistory");
+    if (successor && targetIdx > 0) {
+      const predecessor = entries[targetIdx - 1];
+      successor.previousHash = predecessor.previousHash;
+      await store.put(successor);
+    }
+    await store.delete(target.id);
+    await tx.done;
+  }
+};
+
+export {
+  IndexedDBEngine
+};

package/dist/chunk-OUW2SUGM.js

@@ -0,0 +1,368 @@
+import {
+  Either
+} from "./chunk-2KADE3SE.js";
+import {
+  LLM_DEFAULT_RETRY_COUNT,
+  LLM_DEFAULT_RETRY_DELAY_SECS,
+  LLM_DEFAULT_TIMEOUT_SECS
+} from "./chunk-3FFEA2XK.js";
+
+// src/ptr/llm/providers/LLMProvider.ts
+var BaseLLMProvider = class {
+  async get_status() {
+    const available = await this.validate_connection();
+    let models = [];
+    if (available) {
+      const result = await this.list_models();
+      if (result.isRight) {
+        models = result.right;
+      } else {
+        models = result.left;
+      }
+    } else {
+      models = "Not connected";
+    }
+    return {
+      provider: this.provider_name,
+      available,
+      models: Array.isArray(models) ? models : [],
+      error: typeof models === "string" ? models : null
+    };
+  }
+};
+
+// src/ptr/llm/Config.ts
+var DEFAULT_PROVIDER = "ollama";
+var LLM_PROVIDERS = {
+  "ollama": {
+    base_url: "http://localhost:11434",
+    api_path: "/api/generate",
+    chat_path: "/api/chat",
+    models_path: "/api/tags",
+    default_model: "gemma3:latest",
+    available_models: ["gemma3:latest", "llama3:latest", "qwen3:latest"]
+  },
+  "webllm": {
+    base_url: "",
+    // running in-browser
+    api_path: "",
+    chat_path: "",
+    models_path: null,
+    default_model: "Llama-3-8B-Instruct-q4f32_1-MLC",
+    available_models: ["Llama-3-8B-Instruct-q4f32_1-MLC", "Hermes-2-Pro-Llama-3-8B-q4f16_1-MLC", "Phi-3-Mini-4k-Instruct-q4f16_1-MLC"]
+  },
+  "mlc-llm": {
+    base_url: "http://localhost:8000",
+    api_path: "/v1/completions",
+    chat_path: "/v1/chat/completions",
+    models_path: "/v1/models",
+    default_model: "Llama-3-8B-Instruct-q4f16_1-MLC",
+    available_models: []
+  },
+  "lmstudio": {
+    base_url: "http://localhost:1234",
+    api_path: "/v1/completions",
+    chat_path: "/v1/chat/completions",
+    models_path: "/v1/models",
+    default_model: "local-model",
+    available_models: []
+  },
+  "openai": {
+    base_url: "https://api.openai.com",
+    api_path: "/v1/completions",
+    chat_path: "/v1/chat/completions",
+    models_path: "/v1/models",
+    default_model: "gpt-4",
+    available_models: ["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"]
+  },
+  "anthropic": {
+    base_url: "https://api.anthropic.com",
+    api_path: "/v1/messages",
+    chat_path: "/v1/messages",
+    models_path: null,
+    default_model: "claude-3-sonnet-20240229",
+    available_models: ["claude-3-opus", "claude-3-sonnet", "claude-3-haiku"]
+  }
+};
+var DEFAULT_LLM_CONFIG = {
+  temperature: 0.7,
+  max_tokens: 2048,
+  top_p: 1,
+  top_k: 40,
+  timeout: LLM_DEFAULT_TIMEOUT_SECS,
+  stream: false,
+  response_format: "text",
+  retry_count: LLM_DEFAULT_RETRY_COUNT,
+  retry_delay: LLM_DEFAULT_RETRY_DELAY_SECS
+};
+var RESPONSE_FORMATS = ["text", "json", "structured", "markdown"];
+var LLMConfig = class _LLMConfig {
+  provider;
+  model;
+  endpoint_url;
+  api_key;
+  system_prompt;
+  assistant_instruction;
+  temperature;
+  max_tokens;
+  top_p;
+  top_k;
+  frequency_penalty;
+  presence_penalty;
+  stop_sequences;
+  response_format;
+  json_schema;
+  timeout;
+  retry_count;
+  retry_delay;
+  stream;
+  constructor(data = {}) {
+    this.provider = data.provider || DEFAULT_PROVIDER;
+    this.model = data.model || null;
+    this.endpoint_url = data.endpoint_url || null;
+    this.api_key = data.api_key || null;
+    this.system_prompt = data.system_prompt || "";
+    this.assistant_instruction = data.assistant_instruction || "";
+    this.temperature = data.temperature ?? DEFAULT_LLM_CONFIG.temperature;
+    this.max_tokens = data.max_tokens ?? DEFAULT_LLM_CONFIG.max_tokens;
+    this.top_p = data.top_p ?? DEFAULT_LLM_CONFIG.top_p;
+    this.top_k = data.top_k ?? DEFAULT_LLM_CONFIG.top_k;
+    this.frequency_penalty = data.frequency_penalty || 0;
+    this.presence_penalty = data.presence_penalty || 0;
+    this.stop_sequences = data.stop_sequences || [];
+    this.response_format = data.response_format || DEFAULT_LLM_CONFIG.response_format;
+    this.json_schema = data.json_schema || null;
+    this.timeout = data.timeout ?? DEFAULT_LLM_CONFIG.timeout;
+    this.retry_count = data.retry_count ?? DEFAULT_LLM_CONFIG.retry_count;
+    this.retry_delay = data.retry_delay ?? DEFAULT_LLM_CONFIG.retry_delay;
+    this.stream = data.stream ?? DEFAULT_LLM_CONFIG.stream;
+    this.validate();
+  }
+  validate() {
+    if (!LLM_PROVIDERS[this.provider]) {
+      throw new Error(`Unknown provider: ${this.provider}. Available: ${Object.keys(LLM_PROVIDERS).join(", ")}`);
+    }
+    if (!RESPONSE_FORMATS.includes(this.response_format)) {
+      throw new Error(`Unknown response format: ${this.response_format}. Available: ${RESPONSE_FORMATS.join(", ")}`);
+    }
+  }
+  get effective_model() {
+    return this.model || LLM_PROVIDERS[this.provider].default_model;
+  }
+  get effective_base_url() {
+    if (this.endpoint_url) {
+      return this.endpoint_url.replace(/\/$/, "");
+    }
+    return LLM_PROVIDERS[this.provider].base_url;
+  }
+  to_provider_params() {
+    const params = {
+      model: this.effective_model,
+      temperature: this.temperature
+    };
+    if (this.provider === "ollama") {
+      params.options = {
+        num_predict: this.max_tokens,
+        top_p: this.top_p,
+        top_k: this.top_k,
+        temperature: this.temperature
+      };
+      if (this.stop_sequences.length > 0) {
+        params.options.stop = this.stop_sequences;
+      }
+    } else {
+      params.max_tokens = this.max_tokens;
+      params.top_p = this.top_p;
+      if (this.stop_sequences.length > 0) {
+        params.stop = this.stop_sequences;
+      }
+      if (this.frequency_penalty) params.frequency_penalty = this.frequency_penalty;
+      if (this.presence_penalty) params.presence_penalty = this.presence_penalty;
+    }
+    return params;
+  }
+  static from_concrete(concrete, context = {}) {
+    const configData = { ...concrete.llm_config || {} };
+    ["provider", "model", "system_prompt", "temperature", "max_tokens"].forEach((key) => {
+      if (key in concrete) {
+        configData[key] = concrete[key];
+      }
+    });
+    const contextKeys = [
+      "provider",
+      "model",
+      "endpoint_url",
+      "api_key",
+      "system_prompt",
+      "assistant_instruction",
+      "temperature",
+      "max_tokens",
+      "top_p",
+      "top_k",
+      "response_format",
+      "timeout"
+    ];
+    contextKeys.forEach((key) => {
+      if (key in context) {
+        configData[key] = context[key];
+      }
+    });
+    return new _LLMConfig(configData);
+  }
+};
+
+// src/ptr/llm/providers/OllamaProvider.ts
+import * as http from "http";
+import * as https from "https";
+var OllamaProvider = class extends BaseLLMProvider {
+  provider_name = "ollama";
+  base_url;
+  timeout;
+  config;
+  constructor(base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
+    super();
+    this.config = LLM_PROVIDERS["ollama"];
+    this.base_url = (base_url || this.config.base_url).replace(/\/$/, "");
+    this.timeout = timeout * 1e3;
+  }
+  async _make_request(endpoint, data = null, method = "POST") {
+    const urlStr = `${this.base_url}${endpoint}`;
+    const url = new URL(urlStr);
+    const isHttps = url.protocol === "https:";
+    const client = isHttps ? https : http;
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      timeout: this.timeout
+    };
+    return new Promise((resolve) => {
+      let payload;
+      if (data) {
+        payload = JSON.stringify(data);
+        options.headers["Content-Length"] = Buffer.byteLength(payload);
+      }
+      const req = client.request(url, options, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              if (body.includes("\n") && !body.trim().startsWith("{")) {
+                resolve(Either.right(JSON.parse(body)));
+              } else {
+                resolve(Either.right(JSON.parse(body)));
+              }
+            } catch (e) {
+              const lines = body.trim().split("\n").filter((l) => l);
+              if (lines.length > 0) {
+                try {
+                  resolve(Either.right(JSON.parse(lines[lines.length - 1])));
+                } catch (parseErr) {
+                  resolve(Either.left(`Ollama response parse error: ${parseErr}`));
+                }
+              } else {
+                resolve(Either.left(`Ollama response parse error: ${e}`));
+              }
+            }
+          } else {
+            resolve(Either.left(`Ollama HTTP error ${res.statusCode}: ${body}`));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        resolve(Either.left(`Ollama connection error: ${e.message}`));
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(Either.left(`Ollama request timed out after ${this.timeout}ms`));
+      });
+      if (payload) {
+        req.write(payload);
+      }
+      req.end();
+    });
+  }
+  async complete(prompt, params, images) {
+    const data = {
+      model: typeof params.model === "string" ? params.model : this.config.default_model,
+      prompt,
+      stream: false
+    };
+    if (images && images.length > 0) {
+      data.images = images;
+    }
+    if (params.options) {
+      data.options = params.options;
+    }
+    const result = await this._make_request(this.config.api_path, data);
+    if (result.isLeft) {
+      return Either.left(result.left);
+    }
+    const response = result.right;
+    if (response.response !== void 0) {
+      return Either.right(response.response);
+    } else if (response.error) {
+      return Either.left(`Ollama error: ${response.error}`);
+    } else {
+      return Either.left(`Unexpected Ollama response format: ${JSON.stringify(response)}`);
+    }
+  }
+  async chat(messages, params) {
+    const data = {
+      model: typeof params.model === "string" ? params.model : this.config.default_model,
+      messages,
+      stream: false
+    };
+    if (params.options) {
+      data.options = params.options;
+    }
+    const result = await this._make_request(this.config.chat_path, data);
+    if (result.isLeft) {
+      return Either.left(result.left);
+    }
+    const response = result.right;
+    if (response.message) {
+      return Either.right({
+        content: response.message.content || "",
+        role: response.message.role || "assistant",
+        model: response.model || data.model,
+        done: response.done ?? true,
+        total_duration: response.total_duration,
+        eval_count: response.eval_count
+      });
+    } else if (response.error) {
+      return Either.left(`Ollama error: ${response.error}`);
+    } else {
+      return Either.left(`Unexpected Ollama chat response format: ${JSON.stringify(response)}`);
+    }
+  }
+  async validate_connection() {
+    const result = await this._make_request(this.config.models_path, null, "GET");
+    return result.isRight;
+  }
+  async list_models() {
+    const result = await this._make_request(this.config.models_path, null, "GET");
+    if (result.isLeft) {
+      return Either.left(result.left);
+    }
+    const response = result.right;
+    if (response.models) {
+      const models = response.models.map((m) => m.name || m.model || "unknown");
+      return Either.right(models);
+    } else {
+      return Either.left(`Unexpected models response: ${JSON.stringify(response)}`);
+    }
+  }
+};
+
+export {
+  DEFAULT_PROVIDER,
+  LLM_PROVIDERS,
+  LLMConfig,
+  BaseLLMProvider,
+  OllamaProvider
+};