@gmickel/gno 0.14.1 → 0.15.0

package/README.md

@@ -6,6 +6,7 @@
 [![MIT License](./assets/badges/license.svg)](./LICENSE)
 [![Website](./assets/badges/website.svg)](https://gno.sh)
 [![Twitter](./assets/badges/twitter.svg)](https://twitter.com/gmickel)
+[![Discord](./assets/badges/discord.svg)](https://discord.gg/nHEmyJB5tg)
 
 > **ClawdHub**: GNO skills bundled for Clawdbot — [clawdhub.com/gmickel/gno](https://clawdhub.com/gmickel/gno)
 

package/assets/badges/discord.svg

@@ -0,0 +1,22 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="110" height="28" viewBox="0 0 110 28">
+  <defs>
+    <linearGradient id="bg3" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#1a1a2e"/>
+      <stop offset="100%" style="stop-color:#0f0f1a"/>
+    </linearGradient>
+    <filter id="glow3">
+      <feGaussianBlur stdDeviation="0.5" result="coloredBlur"/>
+      <feMerge>
+        <feMergeNode in="coloredBlur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+  <rect width="110" height="28" rx="6" fill="url(#bg3)"/>
+  <rect x="1" y="1" width="108" height="26" rx="5" fill="none" stroke="#5865F2" stroke-opacity="0.4"/>
+  <!-- Discord logo -->
+  <g transform="translate(10, 6)" fill="#5865F2">
+    <path d="M13.5 4.5C12.5 4 11.4 3.6 10.3 3.4C10.2 3.6 10 3.9 9.9 4.1C8.7 3.9 7.5 3.9 6.4 4.1C6.3 3.9 6.1 3.6 6 3.4C4.9 3.6 3.8 4 2.8 4.5C0.7 7.6 0.1 10.6 0.4 13.6C1.7 14.5 2.9 15.1 4.1 15.5C4.4 15.1 4.7 14.6 4.9 14.1C4.4 13.9 4 13.7 3.6 13.4C3.7 13.3 3.8 13.2 3.9 13.1C6.5 14.3 9.3 14.3 11.9 13.1C12 13.2 12.1 13.3 12.2 13.4C11.8 13.7 11.4 13.9 10.9 14.1C11.1 14.6 11.4 15.1 11.7 15.5C12.9 15.1 14.1 14.5 15.4 13.6C15.7 10.1 14.8 7.1 13.5 4.5ZM5.3 11.6C4.6 11.6 4 10.9 4 10.1C4 9.3 4.6 8.6 5.3 8.6C6 8.6 6.6 9.3 6.6 10.1C6.6 10.9 6 11.6 5.3 11.6ZM10.5 11.6C9.8 11.6 9.2 10.9 9.2 10.1C9.2 9.3 9.8 8.6 10.5 8.6C11.2 8.6 11.8 9.3 11.8 10.1C11.8 10.9 11.2 11.6 10.5 11.6Z" transform="scale(1)"/>
+  </g>
+  <text x="32" y="18" font-family="ui-monospace,SFMono-Regular,Menlo,Monaco,monospace" font-size="12" font-weight="500" fill="#e2e8f0" filter="url(#glow3)">Discord</text>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",
@@ -43,6 +43,7 @@
     "start": "bun run src/index.ts",
     "lint": "oxlint --fix --type-aware --type-check && oxfmt .",
     "lint:check": "oxlint --type-aware --type-check && oxfmt --check .",
+    "typecheck": "bunx tsc --noEmit",
     "test": "bun test",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
@@ -109,7 +110,7 @@
     "remark-gfm": "^4.0.1",
     "shiki": "^3.20.0",
     "sqlite-vec": "^0.1.7-alpha.2",
-    "streamdown": "^1.6.10",
+    "streamdown": "^2.0.1",
     "tailwind-merge": "^3.4.0",
     "tailwindcss": "^4.1.18",
     "use-stick-to-bottom": "^1.1.1",

package/src/cli/commands/embed.ts

@@ -154,8 +154,20 @@ async function processBatches(ctx: BatchContext): Promise<BatchResult> {
     );
     if (!batchEmbedResult.ok) {
       if (ctx.verbose) {
+        const err = batchEmbedResult.error;
+        const cause = err.cause;
+        const causeMsg =
+          cause && typeof cause === "object" && "message" in cause
+            ? (cause as { message: string }).message
+            : typeof cause === "string"
+              ? cause
+              : "";
+        const titles = batch
+          .slice(0, 3)
+          .map((b) => b.title ?? b.mirrorHash.slice(0, 8))
+          .join(", ");
         process.stderr.write(
-          `\n[embed] Batch failed: ${batchEmbedResult.error.message}\n`
+          `\n[embed] Batch failed (${batch.length} chunks: ${titles}${batch.length > 3 ? "..." : ""}): ${err.message}${causeMsg ? ` - ${causeMsg}` : ""}\n`
         );
       }
       errors += batch.length;

package/src/llm/httpEmbedding.ts

@@ -0,0 +1,197 @@
+/**
+ * HTTP-based embedding port implementation.
+ * Calls OpenAI-compatible embedding endpoints.
+ *
+ * @module src/llm/httpEmbedding
+ */
+
+import type { EmbeddingPort, LlmResult } from "./types";
+
+import { inferenceFailedError } from "./errors";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface OpenAIEmbeddingResponse {
+  data: Array<{
+    embedding: number[];
+    index: number;
+    object: string;
+  }>;
+  model: string;
+  object: string;
+  usage: {
+    prompt_tokens: number;
+    total_tokens: number;
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class HttpEmbedding implements EmbeddingPort {
+  private readonly apiUrl: string;
+  private readonly modelName: string;
+  private dims: number | null = null;
+  readonly modelUri: string;
+
+  constructor(modelUri: string) {
+    this.modelUri = modelUri;
+    // Parse URI: http://host:port/v1/embeddings#modelname or just http://host:port
+    const hashIndex = modelUri.indexOf("#");
+    if (hashIndex > 0) {
+      this.apiUrl = modelUri.slice(0, hashIndex);
+      this.modelName = modelUri.slice(hashIndex + 1);
+    } else {
+      this.apiUrl = modelUri;
+      // Try to extract model name from URL path or use default
+      const url = new URL(modelUri);
+      const pathParts = url.pathname.split("/");
+      this.modelName = pathParts[pathParts.length - 1] || "embedding-model";
+    }
+  }
+
+  async init(): Promise<LlmResult<void>> {
+    // Test connection with a simple embedding
+    const result = await this.embed("test");
+    if (!result.ok) {
+      return result;
+    }
+    return { ok: true, value: undefined };
+  }
+
+  async embed(text: string): Promise<LlmResult<number[]>> {
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          input: text,
+          model: this.modelName,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          ok: false,
+          error: inferenceFailedError(
+            this.modelUri,
+            new Error(`HTTP ${response.status}: ${errorText}`)
+          ),
+        };
+      }
+
+      const data = (await response.json()) as OpenAIEmbeddingResponse;
+      const vector = data.data[0]?.embedding;
+
+      if (!vector || !Array.isArray(vector)) {
+        return {
+          ok: false,
+          error: inferenceFailedError(
+            this.modelUri,
+            new Error("Invalid response format: missing embedding")
+          ),
+        };
+      }
+
+      // Cache dimensions on first call
+      if (this.dims === null) {
+        this.dims = vector.length;
+      }
+
+      return { ok: true, value: vector };
+    } catch (e) {
+      return {
+        ok: false,
+        error: inferenceFailedError(
+          this.modelUri,
+          e instanceof Error ? e : new Error(String(e))
+        ),
+      };
+    }
+  }
+
+  async embedBatch(texts: string[]): Promise<LlmResult<number[][]>> {
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          input: texts,
+          model: this.modelName,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          ok: false,
+          error: inferenceFailedError(
+            this.modelUri,
+            new Error(`HTTP ${response.status}: ${errorText}`)
+          ),
+        };
+      }
+
+      const data = (await response.json()) as OpenAIEmbeddingResponse;
+
+      // Sort by index to maintain order
+      const sorted = data.data.sort((a, b) => a.index - b.index);
+      const vectors = sorted.map((item) => item.embedding);
+
+      // Validate all embeddings
+      for (let i = 0; i < vectors.length; i++) {
+        if (!vectors[i] || !Array.isArray(vectors[i])) {
+          return {
+            ok: false,
+            error: inferenceFailedError(
+              this.modelUri,
+              new Error(`Invalid embedding at index ${i}`)
+            ),
+          };
+        }
+      }
+
+      // Cache dimensions on first call
+      if (this.dims === null && vectors.length > 0 && vectors[0]) {
+        this.dims = vectors[0].length;
+      }
+
+      return { ok: true, value: vectors };
+    } catch (e) {
+      return {
+        ok: false,
+        error: inferenceFailedError(
+          this.modelUri,
+          e instanceof Error ? e : new Error(String(e))
+        ),
+      };
+    }
+  }
+
+  dimensions(): number {
+    if (this.dims === null) {
+      throw new Error("Call init() or embed() first to initialize dimensions");
+    }
+    return this.dims;
+  }
+
+  async dispose(): Promise<void> {
+    // Nothing to dispose for HTTP client
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// URI Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function isHttpModelUri(uri: string): boolean {
+  return uri.startsWith("http://") || uri.startsWith("https://");
+}

package/src/llm/httpGeneration.ts

@@ -0,0 +1,119 @@
+/**
+ * HTTP-based generation port implementation.
+ * Calls OpenAI-compatible chat completion endpoints.
+ *
+ * @module src/llm/httpGeneration
+ */
+
+import type { GenerationPort, GenParams, LlmResult } from "./types";
+
+import { inferenceFailedError } from "./errors";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface OpenAIChatResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string;
+      reasoning_content?: string; // Qwen3 thinking mode
+    };
+    finish_reason: string;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class HttpGeneration implements GenerationPort {
+  private readonly apiUrl: string;
+  private readonly modelName: string;
+  readonly modelUri: string;
+
+  constructor(modelUri: string) {
+    this.modelUri = modelUri;
+    // Parse URI: http://host:port/v1/chat/completions#modelname
+    const hashIndex = modelUri.indexOf("#");
+    if (hashIndex > 0) {
+      this.apiUrl = modelUri.slice(0, hashIndex);
+      this.modelName = modelUri.slice(hashIndex + 1);
+    } else {
+      this.apiUrl = modelUri;
+      // Try to extract model name from URL path or use default
+      const url = new URL(modelUri);
+      const pathParts = url.pathname.split("/");
+      this.modelName = pathParts[pathParts.length - 1] || "llama";
+    }
+  }
+
+  async generate(
+    prompt: string,
+    params?: GenParams
+  ): Promise<LlmResult<string>> {
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model: this.modelName,
+          messages: [{ role: "user", content: prompt }],
+          temperature: params?.temperature ?? 0,
+          max_tokens: params?.maxTokens ?? 256,
+          stop: params?.stop,
+          seed: params?.seed,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          ok: false,
+          error: inferenceFailedError(
+            this.modelUri,
+            new Error(`HTTP ${response.status}: ${errorText}`)
+          ),
+        };
+      }
+
+      const data = (await response.json()) as OpenAIChatResponse;
+      const content = data.choices[0]?.message?.content ?? "";
+
+      return { ok: true, value: content };
+    } catch (e) {
+      return {
+        ok: false,
+        error: inferenceFailedError(
+          this.modelUri,
+          e instanceof Error ? e : new Error(String(e))
+        ),
+      };
+    }
+  }
+
+  async dispose(): Promise<void> {
+    // Nothing to dispose for HTTP client
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// URI Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function isHttpGenUri(uri: string): boolean {
+  return uri.startsWith("http://") || uri.startsWith("https://");
+}

package/src/llm/httpRerank.ts

@@ -0,0 +1,191 @@
+/**
+ * HTTP-based rerank port implementation.
+ * Calls OpenAI-compatible completions endpoints for reranking.
+ *
+ * @module src/llm/httpRerank
+ */
+
+import type { LlmResult, RerankPort, RerankScore } from "./types";
+
+import { inferenceFailedError } from "./errors";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface OpenAICompletionResponse {
+  choices: Array<{
+    text: string;
+    index: number;
+    logprobs?: unknown;
+    finish_reason: string;
+  }>;
+  model: string;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class HttpRerank implements RerankPort {
+  private readonly apiUrl: string;
+  private readonly modelName: string;
+  private readonly instruction: string;
+  readonly modelUri: string;
+
+  constructor(modelUri: string) {
+    this.modelUri = modelUri;
+    // Parse URI: http://host:port/v1/completions#modelname
+    const hashIndex = modelUri.indexOf("#");
+    if (hashIndex > 0) {
+      this.apiUrl = modelUri.slice(0, hashIndex);
+      this.modelName = modelUri.slice(hashIndex + 1);
+    } else {
+      this.apiUrl = modelUri;
+      const url = new URL(modelUri);
+      const pathParts = url.pathname.split("/");
+      this.modelName = pathParts[pathParts.length - 1] || "reranker-model";
+    }
+    // Default instruction for retrieval tasks
+    this.instruction =
+      "Given a web search query, retrieve relevant passages that answer the query";
+  }
+
+  async rerank(
+    query: string,
+    documents: string[]
+  ): Promise<LlmResult<RerankScore[]>> {
+    if (documents.length === 0) {
+      return { ok: true, value: [] };
+    }
+
+    try {
+      // Build prompts for all documents
+      const prompts = documents.map((doc) => this.buildPrompt(query, doc));
+
+      // Score all documents in a single batch request
+      const scoresResult = await this.scoreBatch(prompts);
+
+      if (!scoresResult.ok) {
+        return { ok: false, error: scoresResult.error };
+      }
+
+      // Map scores back to document indices
+      const scores = scoresResult.value.map((score, index) => ({
+        index,
+        score,
+      }));
+
+      // Sort by score descending
+      scores.sort((a, b) => b.score - a.score);
+
+      // Assign ranks
+      const rankedScores: RerankScore[] = scores.map((item, rank) => ({
+        index: item.index,
+        score: item.score,
+        rank: rank + 1,
+      }));
+
+      return { ok: true, value: rankedScores };
+    } catch (e) {
+      return {
+        ok: false,
+        error: inferenceFailedError(
+          this.modelUri,
+          e instanceof Error ? e : new Error(String(e))
+        ),
+      };
+    }
+  }
+
+  private buildPrompt(query: string, document: string): string {
+    return `<Instruct>: ${this.instruction}\n<Query>: ${query}\n<Document>: ${document}\n<Score>:`;
+  }
+
+  private async scoreBatch(prompts: string[]): Promise<LlmResult<number[]>> {
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model: this.modelName,
+          prompt: prompts, // Array of prompts for batching
+          max_tokens: 10, // Just need the score
+          temperature: 0, // Deterministic
+          stop: ["\n", "<"],
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          ok: false,
+          error: inferenceFailedError(
+            this.modelUri,
+            new Error(`HTTP ${response.status}: ${errorText}`)
+          ),
+        };
+      }
+
+      const data = (await response.json()) as OpenAICompletionResponse;
+
+      // Parse scores from all choices
+      const scores: number[] = data.choices.map((choice) => {
+        const text = choice.text?.trim() ?? "";
+
+        // Parse score from response
+        const scoreMatch = text.match(/[-+]?[0-9]*\.?[0-9]+/);
+        if (!scoreMatch) {
+          return 0; // Default low score if no number found
+        }
+
+        const score = parseFloat(scoreMatch[0]);
+        return this.normalizeScore(score);
+      });
+
+      return { ok: true, value: scores };
+    } catch (e) {
+      return {
+        ok: false,
+        error: inferenceFailedError(
+          this.modelUri,
+          e instanceof Error ? e : new Error(String(e))
+        ),
+      };
+    }
+  }
+
+  private normalizeScore(score: number): number {
+    // Handle different score ranges
+    if (score < -10 || score > 10) {
+      // Likely logit or unbounded, apply sigmoid-like normalization
+      return 1 / (1 + Math.exp(-score));
+    } else if (score >= 0 && score <= 1) {
+      // Already normalized
+      return score;
+    } else {
+      // Assume -5 to 5 range, normalize to 0-1
+      const normalized = (score + 5) / 10;
+      return Math.max(0, Math.min(1, normalized));
+    }
+  }
+
+  async dispose(): Promise<void> {
+    // Nothing to dispose for HTTP client
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// URI Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function isHttpRerankUri(uri: string): boolean {
+  return uri.startsWith("http://") || uri.startsWith("https://");
+}

package/src/llm/index.ts

@@ -26,6 +26,12 @@ export {
 } from "./errors";
 // Adapter
 export { createLlmAdapter, LlmAdapter } from "./nodeLlamaCpp/adapter";
+// HTTP Embedding
+export { HttpEmbedding, isHttpModelUri } from "./httpEmbedding";
+// HTTP Generation
+export { HttpGeneration, isHttpGenUri } from "./httpGeneration";
+// HTTP Rerank
+export { HttpRerank, isHttpRerankUri } from "./httpRerank";
 // Lifecycle
 export {
   getModelManager,

package/src/llm/nodeLlamaCpp/adapter.ts

@@ -16,6 +16,9 @@ import type {
 } from "../types";
 
 import { ModelCache } from "../cache";
+import { HttpEmbedding, isHttpModelUri } from "../httpEmbedding";
+import { HttpGeneration, isHttpGenUri } from "../httpGeneration";
+import { HttpRerank, isHttpRerankUri } from "../httpRerank";
 import { getActivePreset, getModelConfig } from "../registry";
 import { NodeLlamaCppEmbedding } from "./embedding";
 import { NodeLlamaCppGeneration } from "./generation";
@@ -54,6 +57,7 @@ export class LlmAdapter {
 
   /**
    * Create an embedding port.
+   * Supports HTTP endpoints for remote embedding models.
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createEmbeddingPort(
@@ -64,6 +68,17 @@ export class LlmAdapter {
     const uri = modelUri ?? preset.embed;
     const policy = options?.policy ?? DEFAULT_POLICY;
 
+    // Use HTTP embedding for remote endpoints
+    if (isHttpModelUri(uri)) {
+      const httpEmbed = new HttpEmbedding(uri);
+      // Initialize to verify connection and get dimensions
+      const initResult = await httpEmbed.init();
+      if (!initResult.ok) {
+        return { ok: false, error: initResult.error };
+      }
+      return { ok: true, value: httpEmbed };
+    }
+
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,
@@ -83,6 +98,7 @@ export class LlmAdapter {
 
   /**
    * Create a generation port.
+   * Supports HTTP endpoints for remote generation models.
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createGenerationPort(
@@ -93,6 +109,12 @@ export class LlmAdapter {
     const uri = modelUri ?? preset.gen;
     const policy = options?.policy ?? DEFAULT_POLICY;
 
+    // Use HTTP generation for remote endpoints
+    if (isHttpGenUri(uri)) {
+      const httpGen = new HttpGeneration(uri);
+      return { ok: true, value: httpGen };
+    }
+
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,
@@ -112,6 +134,7 @@ export class LlmAdapter {
 
   /**
    * Create a rerank port.
+   * Supports HTTP endpoints for remote reranking models.
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createRerankPort(
@@ -122,6 +145,12 @@ export class LlmAdapter {
     const uri = modelUri ?? preset.rerank;
     const policy = options?.policy ?? DEFAULT_POLICY;
 
+    // Use HTTP rerank for remote endpoints
+    if (isHttpRerankUri(uri)) {
+      const httpRerank = new HttpRerank(uri);
+      return { ok: true, value: httpRerank };
+    }
+
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,