mcard-js 2.1.48 → 2.1.49

package/dist/chunk-KVZYFZJ5.js

@@ -0,0 +1,427 @@
+import {
+  BaseLLMProvider,
+  DEFAULT_PROVIDER,
+  LLMConfig,
+  LLM_PROVIDERS,
+  OllamaProvider
+} from "./chunk-OUW2SUGM.js";
+import {
+  IO
+} from "./chunk-MPMRBT5R.js";
+import {
+  Either
+} from "./chunk-2KADE3SE.js";
+import {
+  LLM_DEFAULT_TIMEOUT_SECS
+} from "./chunk-3FFEA2XK.js";
+
+// src/ptr/llm/providers/WebLLMProvider.ts
+function asOptionalNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+var WebLLMProvider = class extends BaseLLMProvider {
+  provider_name = "webllm";
+  config;
+  engine = null;
+  current_model = null;
+  initialization_promise = null;
+  constructor() {
+    super();
+    this.config = LLM_PROVIDERS["webllm"];
+  }
+  async _get_engine(model_id) {
+    if (this.engine && this.current_model === model_id) {
+      return Either.right(this.engine);
+    }
+    if (this.initialization_promise) {
+      await this.initialization_promise;
+      if (this.engine && this.current_model === model_id) {
+        return Either.right(this.engine);
+      }
+    }
+    this.initialization_promise = (async () => {
+      try {
+        if (typeof window === "undefined") {
+          throw new Error("WebLLM only supports browser environments.");
+        }
+        const windowWithWebLLM = window;
+        let webllm = windowWithWebLLM.webllm;
+        if (!webllm) {
+          try {
+            webllm = await import("@mlc-ai/web-llm");
+          } catch (e) {
+            void e;
+          }
+        }
+        if (!webllm) {
+          throw new Error("WebLLM library not found. Please include @mlc-ai/web-llm or add script tag.");
+        }
+        if (!this.engine) {
+          this.engine = await webllm.CreateMLCEngine(model_id, {
+            initProgressCallback: (report) => {
+              console.debug(`[WebLLM] ${report.text}`);
+            }
+          });
+        } else {
+          await this.engine.reload(model_id);
+        }
+        this.current_model = model_id;
+      } catch (e) {
+        this.engine = null;
+        this.current_model = null;
+        throw e;
+      }
+    })();
+    try {
+      await this.initialization_promise;
+      return Either.right(this.engine);
+    } catch (e) {
+      this.initialization_promise = null;
+      const error = e;
+      return Either.left(`WebLLM init failed: ${error.message || String(e)}`);
+    }
+  }
+  async complete(prompt, params, images) {
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
+    const engineResult = await this._get_engine(model);
+    if (engineResult.isLeft) return Either.left(engineResult.left);
+    const engine = engineResult.right;
+    try {
+      const completion = await engine.chat.completions.create({
+        messages: [{ role: "user", content: prompt }],
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
+        stream: false
+      });
+      const content = completion.choices?.[0]?.message?.content || "";
+      return Either.right(content);
+    } catch (e) {
+      const error = e;
+      return Either.left(`WebLLM completion error: ${error.message || String(e)}`);
+    }
+  }
+  async chat(messages, params) {
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
+    const engineResult = await this._get_engine(model);
+    if (engineResult.isLeft) return Either.left(engineResult.left);
+    const engine = engineResult.right;
+    try {
+      const completion = await engine.chat.completions.create({
+        messages,
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
+        stream: false
+      });
+      const choice = completion.choices?.[0];
+      return Either.right({
+        content: choice?.message?.content || "",
+        role: choice?.message?.role || "assistant",
+        model,
+        usage: completion.usage
+      });
+    } catch (e) {
+      const error = e;
+      return Either.left(`WebLLM chat error: ${error.message || String(e)}`);
+    }
+  }
+  async validate_connection() {
+    if (typeof window === "undefined") return false;
+    if (window.webllm) return true;
+    try {
+      await import("@mlc-ai/web-llm");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list_models() {
+    return Either.right(this.config.available_models);
+  }
+};
+
+// src/ptr/llm/providers/MLCLLMProvider.ts
+import * as http from "http";
+import * as https from "https";
+var MLCLLMProvider = class extends BaseLLMProvider {
+  provider_name = "mlc-llm";
+  base_url;
+  timeout;
+  config;
+  constructor(base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
+    super();
+    this.config = LLM_PROVIDERS["mlc-llm"];
+    this.base_url = (base_url || this.config.base_url).replace(/\/$/, "");
+    this.timeout = timeout * 1e3;
+  }
+  async _fetch_json(endpoint, options) {
+    if (typeof globalThis.fetch === "function") {
+      try {
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(`${this.base_url}${endpoint}`, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(id);
+        if (!response.ok) {
+          return Either.left(`HTTP error ${response.status}: ${await response.text()}`);
+        }
+        const data = await response.json();
+        return Either.right(data);
+      } catch (e) {
+        const error = e;
+        return Either.left(`Connection error: ${error.message || String(e)}`);
+      }
+    }
+    return this._node_request(endpoint, options);
+  }
+  _node_request(endpoint, options) {
+    const urlStr = `${this.base_url}${endpoint}`;
+    const url = new URL(urlStr);
+    const isHttps = url.protocol === "https:";
+    const client = isHttps ? https : http;
+    const reqOptions = {
+      method: options.method || "GET",
+      headers: options.headers || {},
+      timeout: this.timeout
+    };
+    return new Promise((resolve) => {
+      const req = client.request(url, reqOptions, (res) => {
+        let body = "";
+        res.on("data", (chunk) => body += chunk);
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(Either.right(JSON.parse(body)));
+            } catch (e) {
+              resolve(Either.left(`Parse error: ${e}`));
+            }
+          } else {
+            resolve(Either.left(`HTTP Error ${res.statusCode}: ${body}`));
+          }
+        });
+      });
+      req.on("error", (e) => resolve(Either.left(e.message)));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(Either.left("Request timed out"));
+      });
+      if (options.body) {
+        req.write(options.body);
+      }
+      req.end();
+    });
+  }
+  async complete(prompt, params, images) {
+    const data = {
+      model: typeof params.model === "string" ? params.model : this.config.default_model,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: params.max_tokens,
+      temperature: params.temperature,
+      top_p: params.top_p,
+      stream: false
+    };
+    const result = await this._fetch_json(this.config.api_path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.choices && response.choices.length > 0) {
+      return Either.right(response.choices[0].text || "");
+    }
+    return Either.left(`Unexpected response format: ${JSON.stringify(response)}`);
+  }
+  async chat(messages, params) {
+    const data = {
+      model: params.model || this.config.default_model,
+      messages,
+      max_tokens: params.max_tokens,
+      temperature: params.temperature,
+      top_p: params.top_p,
+      stream: false
+    };
+    const result = await this._fetch_json(this.config.chat_path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.choices && response.choices.length > 0) {
+      const message = response.choices[0].message;
+      return Either.right({
+        content: message?.content || "",
+        role: message?.role || "assistant",
+        model: response.model,
+        usage: response.usage
+      });
+    }
+    return Either.left(`Unexpected response format: ${JSON.stringify(response)}`);
+  }
+  async validate_connection() {
+    const result = await this._fetch_json(this.config.models_path, { method: "GET" });
+    return result.isRight;
+  }
+  async list_models() {
+    const result = await this._fetch_json(this.config.models_path, { method: "GET" });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.data && Array.isArray(response.data)) {
+      return Either.right(response.data.map((m) => m.id).filter((id) => typeof id === "string"));
+    }
+    return Either.left("Invalid models response");
+  }
+};
+
+// src/ptr/llm/LLMRuntime.ts
+function get_provider(provider_name = DEFAULT_PROVIDER, base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
+  if (provider_name === "ollama") {
+    return new OllamaProvider(base_url, timeout);
+  }
+  if (provider_name === "webllm") {
+    return new WebLLMProvider();
+  }
+  if (provider_name === "mlc-llm") {
+    return new MLCLLMProvider(base_url, timeout);
+  }
+  throw new Error(`Unknown provider: ${provider_name}`);
+}
+var LLMRuntime = class {
+  provider_name;
+  _provider = null;
+  constructor(provider_name = DEFAULT_PROVIDER) {
+    this.provider_name = provider_name;
+  }
+  get provider() {
+    if (!this._provider) {
+      this._provider = get_provider(this.provider_name);
+    }
+    return this._provider;
+  }
+  async execute(codeOrPath, context, config, chapterDir) {
+    let configCtx = {};
+    if (typeof context === "object" && context !== null) {
+      configCtx = context;
+    }
+    const concrete = config;
+    const llmConfig = LLMConfig.from_concrete(concrete, configCtx);
+    if (llmConfig.provider !== this.provider_name) {
+      this._provider = get_provider(llmConfig.provider, llmConfig.endpoint_url, llmConfig.timeout);
+    }
+    let prompt = "";
+    let images;
+    if (typeof context === "string") {
+      prompt = context;
+    } else if (context && typeof context === "object") {
+      const ctx = context;
+      if (typeof ctx.prompt === "string") {
+        prompt = ctx.prompt;
+        if (Array.isArray(ctx.images)) {
+          images = ctx.images;
+        }
+      } else {
+        prompt = JSON.stringify(context);
+      }
+    }
+    let result;
+    if (llmConfig.system_prompt) {
+      result = await this._execute_chat(prompt, llmConfig, images);
+    } else {
+      result = await this._execute_completion(prompt, llmConfig, images);
+    }
+    if (result.isLeft) {
+      return `Error: ${result.left}`;
+    }
+    return this._format_response(result.right, llmConfig);
+  }
+  async _execute_completion(prompt, config, images) {
+    const params = config.to_provider_params();
+    return this.provider.complete(prompt, params, images);
+  }
+  async _execute_chat(prompt, config, images) {
+    const messages = [];
+    if (config.system_prompt) {
+      messages.push({ role: "system", content: config.system_prompt });
+    }
+    const userMsg = { role: "user", content: prompt };
+    if (images && images.length > 0) {
+      userMsg.images = images;
+    }
+    messages.push(userMsg);
+    if (config.assistant_instruction) {
+      messages.push({ role: "assistant", content: config.assistant_instruction });
+    }
+    const params = config.to_provider_params();
+    return this.provider.chat(messages, params);
+  }
+  _format_response(response, config) {
+    let content = response;
+    if (response && typeof response === "object" && "content" in response) {
+      content = response.content;
+    }
+    if (config.response_format === "json") {
+      try {
+        if (typeof content === "string") {
+          const start = content.indexOf("{");
+          const end = content.lastIndexOf("}") + 1;
+          if (start >= 0 && end > start) {
+            return JSON.parse(content.substring(start, end));
+          }
+        }
+        return content;
+      } catch (e) {
+        return content;
+      }
+    }
+    return content;
+  }
+};
+function promptMonad(prompt, config = {}) {
+  return IO.of(async () => {
+    try {
+      const llmConfig = new LLMConfig(config);
+      const runtime = new LLMRuntime(llmConfig.provider);
+      const params = llmConfig.to_provider_params();
+      return runtime.provider.complete(prompt, params);
+    } catch (e) {
+      return Either.left(`LLM execution failed: ${e}`);
+    }
+  });
+}
+function chatMonad(messages = null, prompt = null, system_prompt = "", config = {}) {
+  return IO.of(async () => {
+    try {
+      const configData = { ...config };
+      if (system_prompt) configData.system_prompt = system_prompt;
+      const llmConfig = new LLMConfig(configData);
+      const runtime = new LLMRuntime(llmConfig.provider);
+      const msgs = messages ? [...messages] : [];
+      if (msgs.length === 0) {
+        if (llmConfig.system_prompt) {
+          msgs.push({ role: "system", content: llmConfig.system_prompt });
+        }
+        if (prompt) {
+          msgs.push({ role: "user", content: prompt });
+        }
+        if (llmConfig.assistant_instruction) {
+          msgs.push({ role: "assistant", content: llmConfig.assistant_instruction });
+        }
+      }
+      const params = llmConfig.to_provider_params();
+      return runtime.provider.chat(msgs, params);
+    } catch (e) {
+      return Either.left(`LLM chat failed: ${e}`);
+    }
+  });
+}
+
+export {
+  get_provider,
+  LLMRuntime,
+  promptMonad,
+  chatMonad
+};

package/dist/chunk-NGTY4P6A.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-3FFEA2XK.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
+};