lancedb-opencode-pro 0.1.1 → 0.1.2

package/README.md

@@ -10,60 +10,23 @@ LanceDB-backed long-term memory provider for OpenCode.
 
 ## Install
 
-For normal use, install from npm into a fixed local plugin directory:
+### Primary (Recommended): npm package name
 
-```bash
-mkdir -p ~/.config/opencode/plugins/lancedb-opencode-pro
-npm install --prefix ~/.config/opencode/plugins/lancedb-opencode-pro lancedb-opencode-pro
-```
-
-Register the plugin as a `file://` path in `~/.config/opencode/opencode.json`:
+1. Register the published package name in `~/.config/opencode/opencode.json`:
 
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
     "oh-my-opencode",
-    "file:///home/<user>/.config/opencode/plugins/lancedb-opencode-pro/node_modules/lancedb-opencode-pro/dist/index.js"
+    "lancedb-opencode-pro"
   ]
 }
 ```
 
-If you already use other plugins, keep them and append this `file://` entry.
-
-## Fallback Install From Local `.tgz`
-
-Use this flow when you want to install an unpublished build or test a release candidate on another machine.
-
-1. On the build host, build and pack:
-
-```bash
-npm ci
-npm run typecheck
-npm run build
-npm pack
-```
-
-This generates a file like:
-
-```text
-lancedb-opencode-pro-0.1.1.tgz
-```
-
-2. Copy the `.tgz` to the target host (example):
-
-```bash
-scp lancedb-opencode-pro-0.1.1.tgz <user>@<target-host>:/tmp/
-```
-
-3. On the target host, install into a fixed local plugin directory:
-
-```bash
-mkdir -p ~/.config/opencode/plugins/lancedb-opencode-pro
-npm install --prefix ~/.config/opencode/plugins/lancedb-opencode-pro /tmp/lancedb-opencode-pro-0.1.1.tgz
-```
+If you already use other plugins, keep them and append `"lancedb-opencode-pro"`.
 
-4. For OpenCode `1.2.27+`, create the sidecar config file `~/.config/opencode/lancedb-opencode-pro.json`:
+2. For OpenCode `1.2.27+`, create the sidecar config file `~/.config/opencode/lancedb-opencode-pro.json`:
 
 ```json
 {
@@ -86,14 +49,14 @@ npm install --prefix ~/.config/opencode/plugins/lancedb-opencode-pro /tmp/lanced
 }
 ```
 
-5. Set `embedding.baseUrl` to the Ollama endpoint that is reachable from that host.
+3. Set `embedding.baseUrl` to the Ollama endpoint that is reachable from that host.
 
 - Same machine as OpenCode: `http://127.0.0.1:11434`
 - Another machine on the network: for example `http://192.168.11.206:11434`
 
 You do not need `LANCEDB_OPENCODE_PRO_OLLAMA_BASE_URL` if the sidecar file already contains the correct `embedding.baseUrl`. Use the environment variable only when you want to override the file at runtime.
 
-6. Make sure Ollama is reachable from that host before starting OpenCode:
+4. Make sure Ollama is reachable from that host, then start or restart OpenCode:
 
 ```bash
 curl http://127.0.0.1:11434/api/tags
@@ -105,26 +68,57 @@ or, for a remote Ollama server:
 curl http://192.168.11.206:11434/api/tags
 ```
 
-7. Verify plugin file path and start/restart OpenCode:
+After the first successful memory operation, LanceDB files should appear under:
+
+```text
+~/.opencode/memory/lancedb
+```
+
+You can verify that the directory exists:
 
 ```bash
-ls -la ~/.config/opencode/plugins/lancedb-opencode-pro/node_modules/lancedb-opencode-pro/dist/index.js
+ls -la ~/.opencode/memory/lancedb
 ```
 
-Then start or restart OpenCode, and verify memory store initialization.
+## Fallback Install From Release `.tgz`
 
-After the first successful memory operation, LanceDB files should appear under:
+Use this only when npm registry install is unavailable (for example, restricted network, offline staging, or registry outage).
 
-```text
-~/.opencode/memory/lancedb
+1. Download the latest published release asset:
+
+```bash
+curl -fL "https://github.com/tryweb/lancedb-opencode-pro/releases/latest/download/lancedb-opencode-pro.tgz" -o /tmp/lancedb-opencode-pro.tgz
 ```
 
-You can also verify that the directory exists:
+2. Install into the fixed local plugin directory:
 
 ```bash
-ls -la ~/.opencode/memory/lancedb
+mkdir -p ~/.config/opencode/plugins/lancedb-opencode-pro
+npm install --prefix ~/.config/opencode/plugins/lancedb-opencode-pro /tmp/lancedb-opencode-pro.tgz
+```
+
+3. Register the plugin as a `file://` path in `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "oh-my-opencode",
+    "file:///home/<user>/.config/opencode/plugins/lancedb-opencode-pro/node_modules/lancedb-opencode-pro/dist/index.js"
+  ]
+}
 ```
 
+4. Reuse the same sidecar config from the primary install flow, then start/restart OpenCode.
+
+5. Verify plugin file path:
+
+```bash
+ls -la ~/.config/opencode/plugins/lancedb-opencode-pro/node_modules/lancedb-opencode-pro/dist/index.js
+```
+
+Then verify memory store initialization.
+
 ### When to use environment variables
 
 Environment variables are optional. The recommended default is:
@@ -140,6 +134,26 @@ export LANCEDB_OPENCODE_PRO_OLLAMA_BASE_URL="http://192.168.11.206:11434"
 
 This override has higher priority than the sidecar file.
 
+### Secondary Fallback: Build From Source And Pack Locally
+
+Use this when you need an unpublished local build (for example, testing unreleased commits).
+
+```bash
+npm ci
+npm run typecheck
+npm run build
+npm pack
+```
+
+Then install the generated tarball:
+
+```bash
+mkdir -p ~/.config/opencode/plugins/lancedb-opencode-pro
+npm install --prefix ~/.config/opencode/plugins/lancedb-opencode-pro ./lancedb-opencode-pro-<version>.tgz
+```
+
+Use the same `file://` plugin registration shown in the fallback section above.
+
 ## OpenCode Config
 
 Use a sidecar config file. This is the supported configuration model for current OpenCode versions.
@@ -189,9 +203,14 @@ Supported environment variables:
 
 - `LANCEDB_OPENCODE_PRO_CONFIG_PATH`
 - `LANCEDB_OPENCODE_PRO_PROVIDER`
+- `LANCEDB_OPENCODE_PRO_EMBEDDING_PROVIDER` (`ollama` or `openai`, default `ollama`)
 - `LANCEDB_OPENCODE_PRO_DB_PATH`
 - `LANCEDB_OPENCODE_PRO_EMBEDDING_MODEL`
 - `LANCEDB_OPENCODE_PRO_OLLAMA_BASE_URL`
+- `LANCEDB_OPENCODE_PRO_OPENAI_API_KEY`
+- `LANCEDB_OPENCODE_PRO_OPENAI_MODEL`
+- `LANCEDB_OPENCODE_PRO_OPENAI_BASE_URL`
+- `LANCEDB_OPENCODE_PRO_OPENAI_TIMEOUT_MS`
 - `LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS`
 - `LANCEDB_OPENCODE_PRO_RETRIEVAL_MODE`
 - `LANCEDB_OPENCODE_PRO_VECTOR_WEIGHT`
@@ -213,6 +232,51 @@ Supported environment variables:
   - `memory_stats`
   - `memory_port_plan`
 
+## OpenAI Embedding Configuration
+
+Default behavior stays on Ollama. To use OpenAI embeddings, set `embedding.provider` to `openai` and provide API key + model.
+
+Example sidecar:
+
+```json
+{
+  "provider": "lancedb-opencode-pro",
+  "dbPath": "~/.opencode/memory/lancedb",
+  "embedding": {
+    "provider": "openai",
+    "model": "text-embedding-3-small",
+    "baseUrl": "https://api.openai.com/v1",
+    "apiKey": "sk-your-openai-key"
+  },
+  "retrieval": {
+    "mode": "hybrid",
+    "vectorWeight": 0.7,
+    "bm25Weight": 0.3,
+    "minScore": 0.2
+  },
+  "includeGlobalScope": true,
+  "minCaptureChars": 80,
+  "maxEntriesPerScope": 3000
+}
+```
+
+Recommended env overrides for OpenAI:
+
+```bash
+export LANCEDB_OPENCODE_PRO_EMBEDDING_PROVIDER="openai"
+export LANCEDB_OPENCODE_PRO_OPENAI_API_KEY="$OPENAI_API_KEY"
+export LANCEDB_OPENCODE_PRO_OPENAI_MODEL="text-embedding-3-small"
+export LANCEDB_OPENCODE_PRO_OPENAI_BASE_URL="https://api.openai.com/v1"
+```
+
+`lancedb-opencode-pro.json` is parsed as plain JSON, so `${...}` interpolation is not performed. Prefer environment variables for secrets.
+
+Validation behavior:
+
+- If `embedding.provider=openai` and API key is missing, initialization fails with an explicit configuration error.
+- If `embedding.provider=openai` and model is missing, initialization fails with an explicit configuration error.
+- Ollama remains the default provider when `embedding.provider` is omitted.
+
 ## Compose Port Planning (Cross-Project)
 
 Use `memory_port_plan` before writing `docker-compose.yml` to avoid host port collisions across projects on the same machine.
@@ -497,5 +561,5 @@ Treat the feature as verified only when all of these are true:
 ## Notes
 
 - Default storage path: `~/.opencode/memory/lancedb`
-- Embedding backend in v1: `ollama`
+- Embedding provider defaults to `ollama`; `openai` is supported via `embedding.provider=openai`
 - The provider keeps schema metadata (`schemaVersion`, `embeddingModel`, `vectorDim`) to guard against unsafe vector mixing.

package/dist/config.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { clamp, expandHomePath, parseJsonObject, toBoolean, toNumber } from "./utils.js";
 const DEFAULT_DB_PATH = "~/.opencode/memory/lancedb";
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const SIDECAR_FILE = "lancedb-opencode-pro.json";
 export function resolveMemoryConfig(config, worktree) {
     const legacyRaw = (config?.memory ?? {});
@@ -19,14 +20,29 @@ export function resolveMemoryConfig(config, worktree) {
     const weightSum = vectorWeight + bm25Weight;
     const normalizedVectorWeight = weightSum > 0 ? vectorWeight / weightSum : 0.7;
     const normalizedBm25Weight = weightSum > 0 ? bm25Weight / weightSum : 0.3;
-    return {
+    const embeddingProvider = resolveEmbeddingProvider(firstString(process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_PROVIDER, embeddingRaw.provider));
+    const embeddingModel = embeddingProvider === "openai"
+        ? firstString(process.env.LANCEDB_OPENCODE_PRO_OPENAI_MODEL, process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_MODEL, embeddingRaw.model)
+        : firstString(process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_MODEL, embeddingRaw.model) ?? "nomic-embed-text";
+    const embeddingBaseUrl = embeddingProvider === "openai"
+        ? firstString(process.env.LANCEDB_OPENCODE_PRO_OPENAI_BASE_URL, embeddingRaw.baseUrl) ?? DEFAULT_OPENAI_BASE_URL
+        : firstString(process.env.LANCEDB_OPENCODE_PRO_OLLAMA_BASE_URL, embeddingRaw.baseUrl) ?? DEFAULT_OLLAMA_BASE_URL;
+    const embeddingApiKey = embeddingProvider === "openai"
+        ? firstString(process.env.LANCEDB_OPENCODE_PRO_OPENAI_API_KEY, embeddingRaw.apiKey)
+        : undefined;
+    const timeoutEnv = embeddingProvider === "openai"
+        ? process.env.LANCEDB_OPENCODE_PRO_OPENAI_TIMEOUT_MS ?? process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS
+        : process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS;
+    const timeoutRaw = timeoutEnv ?? embeddingRaw.timeoutMs;
+    const resolvedConfig = {
         provider,
         dbPath,
         embedding: {
-            provider: "ollama",
-            model: firstString(process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_MODEL, embeddingRaw.model) ?? "nomic-embed-text",
-            baseUrl: firstString(process.env.LANCEDB_OPENCODE_PRO_OLLAMA_BASE_URL, embeddingRaw.baseUrl) ?? DEFAULT_OLLAMA_BASE_URL,
-            timeoutMs: Math.max(500, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS ?? embeddingRaw.timeoutMs, 6000))),
+            provider: embeddingProvider,
+            model: embeddingModel ?? "",
+            baseUrl: embeddingBaseUrl,
+            apiKey: embeddingApiKey,
+            timeoutMs: Math.max(500, Math.floor(toNumber(timeoutRaw, 6000))),
         },
         retrieval: {
             mode,
@@ -38,6 +54,25 @@ export function resolveMemoryConfig(config, worktree) {
         minCaptureChars: Math.max(30, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_MIN_CAPTURE_CHARS ?? raw.minCaptureChars, 80))),
         maxEntriesPerScope: Math.max(50, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_MAX_ENTRIES_PER_SCOPE ?? raw.maxEntriesPerScope, 3000))),
     };
+    validateEmbeddingConfig(resolvedConfig.embedding);
+    return resolvedConfig;
+}
+function resolveEmbeddingProvider(raw) {
+    if (!raw || raw === "ollama")
+        return "ollama";
+    if (raw === "openai")
+        return "openai";
+    throw new Error(`[lancedb-opencode-pro] Invalid embedding provider "${raw}". Expected "ollama" or "openai".`);
+}
+function validateEmbeddingConfig(embedding) {
+    if (embedding.provider !== "openai")
+        return;
+    if (!embedding.apiKey) {
+        throw new Error("[lancedb-opencode-pro] OpenAI embedding provider requires apiKey. Set embedding.apiKey or LANCEDB_OPENCODE_PRO_OPENAI_API_KEY.");
+    }
+    if (!embedding.model) {
+        throw new Error("[lancedb-opencode-pro] OpenAI embedding provider requires model. Set embedding.model or LANCEDB_OPENCODE_PRO_OPENAI_MODEL.");
+    }
 }
 function loadSidecarConfig(worktree) {
     const configPath = firstString(process.env.LANCEDB_OPENCODE_PRO_CONFIG_PATH);

package/dist/embedder.d.ts

@@ -12,3 +12,12 @@ export declare class OllamaEmbedder implements Embedder {
     embed(text: string): Promise<number[]>;
     dim(): Promise<number>;
 }
+export declare class OpenAIEmbedder implements Embedder {
+    private readonly config;
+    readonly model: string;
+    private cachedDim;
+    constructor(config: EmbeddingConfig);
+    embed(text: string): Promise<number[]>;
+    dim(): Promise<number>;
+}
+export declare function createEmbedder(config: EmbeddingConfig): Embedder;

package/dist/embedder.js

@@ -3,6 +3,9 @@ const KNOWN_MODEL_DIMS = {
     "mxbai-embed-large": 1024,
     "all-minilm": 384,
     "snowflake-arctic-embed": 1024,
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536,
 };
 function fallbackDim(model) {
     const normalized = model.toLowerCase().replace(/:.*$/, "");
@@ -70,3 +73,76 @@ export class OllamaEmbedder {
         }
     }
 }
+export class OpenAIEmbedder {
+    config;
+    model;
+    cachedDim = null;
+    constructor(config) {
+        this.config = config;
+        this.model = config.model;
+    }
+    async embed(text) {
+        if (!this.config.apiKey) {
+            throw new Error("OpenAI embedding request failed: missing apiKey. Set embedding.apiKey or LANCEDB_OPENCODE_PRO_OPENAI_API_KEY.");
+        }
+        const baseUrl = (this.config.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+        const endpoint = `${baseUrl}/embeddings`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 6000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    model: this.config.model,
+                    input: text,
+                    encoding_format: "float",
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const details = await response.text().catch(() => "");
+                const suffix = details ? ` - ${details.slice(0, 240)}` : "";
+                throw new Error(`OpenAI embedding request failed: HTTP ${response.status}${suffix}`);
+            }
+            const data = (await response.json());
+            const vector = data.data?.[0]?.embedding;
+            if (!Array.isArray(vector) || vector.length === 0) {
+                throw new Error("OpenAI embedding response missing embedding vector");
+            }
+            if (this.cachedDim === null) {
+                this.cachedDim = vector.length;
+            }
+            return vector;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async dim() {
+        if (this.cachedDim !== null)
+            return this.cachedDim;
+        try {
+            const probe = await this.embed("dimension probe");
+            this.cachedDim = probe.length;
+            return this.cachedDim;
+        }
+        catch {
+            const fb = fallbackDim(this.model);
+            if (fb !== null) {
+                console.warn(`[lancedb-opencode-pro] OpenAI embedding probe failed, using fallback dim ${fb} for model "${this.model}"`);
+                return fb;
+            }
+            throw new Error(`OpenAI embedding probe failed and no known fallback dimension for model "${this.model}"`);
+        }
+    }
+}
+export function createEmbedder(config) {
+    if (config.provider === "openai") {
+        return new OpenAIEmbedder(config);
+    }
+    return new OllamaEmbedder(config);
+}

package/dist/index.js

@@ -1,6 +1,6 @@
 import { tool } from "@opencode-ai/plugin";
 import { resolveMemoryConfig } from "./config.js";
-import { OllamaEmbedder } from "./embedder.js";
+import { createEmbedder } from "./embedder.js";
 import { extractCaptureCandidate } from "./extract.js";
 import { isTcpPortAvailable, parsePortReservations, planPorts, reservationKey } from "./ports.js";
 import { buildScopeFilter, deriveProjectScope } from "./scope.js";
@@ -11,7 +11,12 @@ const plugin = async (input) => {
     const state = await createRuntimeState(input);
     const hooks = {
         config: async (config) => {
-            state.config = resolveMemoryConfig(config, input.worktree);
+            const nextConfig = resolveMemoryConfig(config, input.worktree);
+            if (hasEmbeddingConfigChanged(state.config.embedding, nextConfig.embedding)) {
+                state.embedder = createEmbedder(nextConfig.embedding);
+                state.initialized = false;
+            }
+            state.config = nextConfig;
         },
         event: async ({ event }) => {
             if (event.type === "session.idle" || event.type === "session.compacted") {
@@ -72,7 +77,7 @@ const plugin = async (input) => {
                 execute: async (args, context) => {
                     await state.ensureInitialized();
                     if (!state.initialized)
-                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                        return unavailableMessage(state.config.embedding.provider);
                     const activeScope = args.scope ?? deriveProjectScope(context.worktree);
                     const scopes = buildScopeFilter(activeScope, state.config.includeGlobalScope);
                     let queryVector = [];
@@ -111,7 +116,7 @@ const plugin = async (input) => {
                 execute: async (args, context) => {
                     await state.ensureInitialized();
                     if (!state.initialized)
-                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                        return unavailableMessage(state.config.embedding.provider);
                     if (!args.confirm) {
                         return "Rejected: memory_delete requires confirm=true.";
                     }
@@ -130,7 +135,7 @@ const plugin = async (input) => {
                 execute: async (args) => {
                     await state.ensureInitialized();
                     if (!state.initialized)
-                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                        return unavailableMessage(state.config.embedding.provider);
                     if (!args.confirm) {
                         return "Rejected: destructive clear requires confirm=true.";
                     }
@@ -146,7 +151,7 @@ const plugin = async (input) => {
                 execute: async (args, context) => {
                     await state.ensureInitialized();
                     if (!state.initialized)
-                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                        return unavailableMessage(state.config.embedding.provider);
                     const scope = args.scope ?? deriveProjectScope(context.worktree);
                     const entries = await state.store.list(scope, 20);
                     const incompatibleVectors = await state.store.countIncompatibleVectors(buildScopeFilter(scope, state.config.includeGlobalScope), await state.embedder.dim());
@@ -180,7 +185,7 @@ const plugin = async (input) => {
                 execute: async (args, context) => {
                     await state.ensureInitialized();
                     if (!state.initialized)
-                        return "Memory store unavailable (Ollama may be offline). Will retry automatically.";
+                        return unavailableMessage(state.config.embedding.provider);
                     if (args.rangeStart > args.rangeEnd) {
                         return "Invalid range: rangeStart must be <= rangeEnd.";
                     }
@@ -261,7 +266,7 @@ const plugin = async (input) => {
 };
 async function createRuntimeState(input) {
     const resolved = resolveMemoryConfig(undefined, input.worktree);
-    const embedder = new OllamaEmbedder(resolved.embedding);
+    const embedder = createEmbedder(resolved.embedding);
     const store = new MemoryStore(resolved.dbPath);
     const state = {
         config: resolved,
@@ -369,4 +374,14 @@ function unwrapData(value) {
     }
     return value;
 }
+function unavailableMessage(provider) {
+    return `Memory store unavailable (${provider} embedding may be offline). Will retry automatically.`;
+}
+function hasEmbeddingConfigChanged(current, next) {
+    return (current.provider !== next.provider
+        || current.model !== next.model
+        || (current.baseUrl ?? "") !== (next.baseUrl ?? "")
+        || (current.apiKey ?? "") !== (next.apiKey ?? "")
+        || (current.timeoutMs ?? 0) !== (next.timeoutMs ?? 0));
+}
 export default plugin;

package/dist/types.d.ts

@@ -1,10 +1,11 @@
-export type EmbeddingProvider = "ollama";
+export type EmbeddingProvider = "ollama" | "openai";
 export type RetrievalMode = "hybrid" | "vector";
 export type MemoryCategory = "preference" | "fact" | "decision" | "entity" | "other";
 export interface EmbeddingConfig {
     provider: EmbeddingProvider;
     model: string;
     baseUrl?: string;
+    apiKey?: string;
     timeoutMs?: number;
 }
 export interface RetrievalConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lancedb-opencode-pro",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",
@@ -25,11 +25,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab-238.ichiayi.com/jonathan/lancedb-opencode-pro.git"
+    "url": "git+https://github.com/tryweb/lancedb-opencode-pro.git"
   },
-  "homepage": "https://gitlab-238.ichiayi.com/jonathan/lancedb-opencode-pro",
+  "homepage": "https://github.com/tryweb/lancedb-opencode-pro",
   "bugs": {
-    "url": "https://gitlab-238.ichiayi.com/jonathan/lancedb-opencode-pro/-/issues"
+    "url": "https://github.com/tryweb/lancedb-opencode-pro/issues"
   },
   "license": "MIT",
   "engines": {

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Jonathan Tsai <tryweb@ichiayi.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.