@gmickel/gno 0.7.0 → 0.8.1

package/src/llm/cache.ts

@@ -6,13 +6,23 @@
  */
 
 // node:crypto: createHash for safe lock filenames
-import { createHash } from 'node:crypto';
-import { mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
+import { createHash } from "node:crypto";
+import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 // node:path: join for path construction, isAbsolute for cross-platform path detection
-import { isAbsolute, join } from 'node:path';
+import { isAbsolute, join } from "node:path";
 // node:url: fileURLToPath for proper file:// URL handling
-import { fileURLToPath } from 'node:url';
-import { getModelsCachePath } from '../app/constants';
+import { fileURLToPath } from "node:url";
+
+import type { DownloadPolicy } from "./policy";
+import type {
+  DownloadProgress,
+  LlmResult,
+  ModelCacheEntry,
+  ModelType,
+  ProgressCallback,
+} from "./types";
+
+import { getModelsCachePath } from "../app/constants";
 import {
   autoDownloadDisabledError,
   downloadFailedError,
@@ -20,16 +30,8 @@ import {
   lockFailedError,
   modelNotCachedError,
   modelNotFoundError,
-} from './errors';
-import { getLockPath, getManifestLockPath, withLock } from './lockfile';
-import type { DownloadPolicy } from './policy';
-import type {
-  DownloadProgress,
-  LlmResult,
-  ModelCacheEntry,
-  ModelType,
-  ProgressCallback,
-} from './types';
+} from "./errors";
+import { getLockPath, getManifestLockPath, withLock } from "./lockfile";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // URI Parsing
@@ -41,14 +43,14 @@ const HF_PATH_PATTERN = /^([^/]+)\/([^/]+)\/(.+\.gguf)$/;
 
 export type ParsedModelUri =
   | {
-      scheme: 'hf';
+      scheme: "hf";
       org: string;
       repo: string;
       file: string;
       quantization?: string;
     }
   | {
-      scheme: 'file';
+      scheme: "file";
       file: string;
     };
 
@@ -69,7 +71,7 @@ export function parseModelUri(
   uri: string
 ): { ok: true; value: ParsedModelUri } | { ok: false; error: string } {
   // Handle hf: scheme
-  if (uri.startsWith('hf:')) {
+  if (uri.startsWith("hf:")) {
     const rest = uri.slice(3);
 
     // Check for quantization shorthand: hf:org/repo:Q4_K_M
@@ -81,10 +83,10 @@ export function parseModelUri(
         return {
           ok: true,
           value: {
-            scheme: 'hf',
+            scheme: "hf",
             org,
             repo,
-            file: '', // Will be resolved by node-llama-cpp
+            file: "", // Will be resolved by node-llama-cpp
             quantization: quant,
           },
         };
@@ -100,7 +102,7 @@ export function parseModelUri(
         return {
           ok: true,
           value: {
-            scheme: 'hf',
+            scheme: "hf",
             org,
             repo,
             file,
@@ -113,12 +115,12 @@ export function parseModelUri(
   }
 
   // Handle file:// URLs (proper file URLs like file:///C:/path or file:///path)
-  if (uri.startsWith('file://')) {
+  if (uri.startsWith("file://")) {
     try {
       const filePath = fileURLToPath(new URL(uri));
       return {
         ok: true,
-        value: { scheme: 'file', file: filePath },
+        value: { scheme: "file", file: filePath },
       };
     } catch {
       return { ok: false, error: `Invalid file URL: ${uri}` };
@@ -126,14 +128,14 @@ export function parseModelUri(
   }
 
   // Handle simplified file: scheme (file:/path or file:C:\path)
-  if (uri.startsWith('file:')) {
+  if (uri.startsWith("file:")) {
     const path = uri.slice(5);
     if (!path) {
-      return { ok: false, error: 'Empty file path' };
+      return { ok: false, error: "Empty file path" };
     }
     return {
       ok: true,
-      value: { scheme: 'file', file: path },
+      value: { scheme: "file", file: path },
     };
   }
 
@@ -141,7 +143,7 @@ export function parseModelUri(
   if (isAbsolute(uri)) {
     return {
       ok: true,
-      value: { scheme: 'file', file: uri },
+      value: { scheme: "file", file: uri },
     };
   }
 
@@ -152,7 +154,7 @@ export function parseModelUri(
  * Convert parsed URI back to node-llama-cpp format.
  */
 export function toNodeLlamaCppUri(parsed: ParsedModelUri): string {
-  if (parsed.scheme === 'file') {
+  if (parsed.scheme === "file") {
     return parsed.file;
   }
 
@@ -168,11 +170,11 @@ export function toNodeLlamaCppUri(parsed: ParsedModelUri): string {
 // ─────────────────────────────────────────────────────────────────────────────
 
 interface Manifest {
-  version: '1.0';
+  version: "1.0";
   models: ModelCacheEntry[];
 }
 
-const MANIFEST_VERSION = '1.0' as const;
+const MANIFEST_VERSION = "1.0" as const;
 
 // ─────────────────────────────────────────────────────────────────────────────
 // ModelCache
@@ -185,7 +187,7 @@ export class ModelCache {
 
   constructor(cacheDir?: string) {
     this.dir = cacheDir ?? getModelsCachePath();
-    this.manifestPath = join(this.dir, 'manifest.json');
+    this.manifestPath = join(this.dir, "manifest.json");
   }
 
   /**
@@ -199,7 +201,7 @@ export class ModelCache {
     }
 
     // Local files: verify existence
-    if (parsed.value.scheme === 'file') {
+    if (parsed.value.scheme === "file") {
       const exists = await this.fileExists(parsed.value.file);
       if (!exists) {
         return {
@@ -238,7 +240,7 @@ export class ModelCache {
     }
 
     // Local files: just verify
-    if (parsed.value.scheme === 'file') {
+    if (parsed.value.scheme === "file") {
       const exists = await this.fileExists(parsed.value.file);
       if (!exists) {
         return {
@@ -266,7 +268,7 @@ export class ModelCache {
     }
 
     try {
-      const { resolveModelFile } = await import('node-llama-cpp');
+      const { resolveModelFile } = await import("node-llama-cpp");
 
       // Convert to node-llama-cpp format (handles quantization shorthand)
       // node-llama-cpp needs hf: prefix to identify HuggingFace models
@@ -279,11 +281,11 @@ export class ModelCache {
               // Type-safe check for download progress status
               if (
                 status &&
-                typeof status === 'object' &&
-                'type' in status &&
-                status.type === 'download' &&
-                'downloadedSize' in status &&
-                'totalSize' in status
+                typeof status === "object" &&
+                "type" in status &&
+                status.type === "download" &&
+                "downloadedSize" in status &&
+                "totalSize" in status
               ) {
                 const s = status as {
                   downloadedSize: number;
@@ -340,7 +342,7 @@ export class ModelCache {
     }
 
     // Local files: just verify existence (no download needed)
-    if (parsed.value.scheme === 'file') {
+    if (parsed.value.scheme === "file") {
       const exists = await this.fileExists(parsed.value.file);
       if (!exists) {
         return {
@@ -366,9 +368,9 @@ export class ModelCache {
     // Acquire lock for download (prevents concurrent downloads of same model)
     // Use hash for lock filename to avoid collisions and path issues
     await mkdir(this.dir, { recursive: true });
-    const lockName = createHash('sha256')
+    const lockName = createHash("sha256")
       .update(uri)
-      .digest('hex')
+      .digest("hex")
       .slice(0, 32);
     const lockPath = getLockPath(join(this.dir, lockName));
 
@@ -409,7 +411,7 @@ export class ModelCache {
   async getCachedPath(uri: string): Promise<string | null> {
     // Handle file: URIs directly (check filesystem, not manifest)
     const parsed = parseModelUri(uri);
-    if (parsed.ok && parsed.value.scheme === 'file') {
+    if (parsed.ok && parsed.value.scheme === "file") {
       const exists = await this.fileExists(parsed.value.file);
       return exists ? parsed.value.file : null;
     }
@@ -505,7 +507,7 @@ export class ModelCache {
    */
   private async readManifestFromDisk(): Promise<Manifest> {
     try {
-      const content = await readFile(this.manifestPath, 'utf-8');
+      const content = await readFile(this.manifestPath, "utf-8");
       return JSON.parse(content) as Manifest;
     } catch {
       // No manifest or invalid - create empty
@@ -539,7 +541,7 @@ export class ModelCache {
     });
 
     if (result === null) {
-      throw new Error('Failed to acquire manifest lock');
+      throw new Error("Failed to acquire manifest lock");
     }
   }
 
@@ -553,7 +555,7 @@ export class ModelCache {
     const content = JSON.stringify(manifest, null, 2);
 
     // Write to temp file with fsync
-    const fh = await open(tmpPath, 'w');
+    const fh = await open(tmpPath, "w");
     try {
       await fh.writeFile(content);
       await fh.sync();
@@ -565,9 +567,9 @@ export class ModelCache {
     await rename(tmpPath, this.manifestPath);
 
     // Fsync parent directory for rename durability (best-effort, not supported on Windows)
-    if (process.platform !== 'win32') {
+    if (process.platform !== "win32") {
       try {
-        const dirFh = await open(this.dir, 'r');
+        const dirFh = await open(this.dir, "r");
         try {
           await dirFh.sync();
         } finally {
@@ -603,7 +605,7 @@ export class ModelCache {
         type,
         path: modelPath,
         size,
-        checksum: '', // TODO: compute SHA-256 for large files
+        checksum: "", // TODO: compute SHA-256 for large files
         cachedAt: new Date().toISOString(),
       });
     });

package/src/llm/errors.ts

@@ -10,17 +10,17 @@
 // ─────────────────────────────────────────────────────────────────────────────
 
 export type LlmErrorCode =
-  | 'MODEL_NOT_FOUND'
-  | 'MODEL_NOT_CACHED'
-  | 'MODEL_DOWNLOAD_FAILED'
-  | 'MODEL_LOAD_FAILED'
-  | 'MODEL_CORRUPTED'
-  | 'INFERENCE_FAILED'
-  | 'TIMEOUT'
-  | 'OUT_OF_MEMORY'
-  | 'INVALID_URI'
-  | 'LOCK_FAILED'
-  | 'AUTO_DOWNLOAD_DISABLED';
+  | "MODEL_NOT_FOUND"
+  | "MODEL_NOT_CACHED"
+  | "MODEL_DOWNLOAD_FAILED"
+  | "MODEL_LOAD_FAILED"
+  | "MODEL_CORRUPTED"
+  | "INFERENCE_FAILED"
+  | "TIMEOUT"
+  | "OUT_OF_MEMORY"
+  | "INVALID_URI"
+  | "LOCK_FAILED"
+  | "AUTO_DOWNLOAD_DISABLED";
 
 export interface LlmError {
   code: LlmErrorCode;
@@ -59,19 +59,23 @@ function normalizeCause(
     return { name: cause.name, message };
   }
 
-  if (typeof cause === 'string') {
+  if (typeof cause === "string") {
     return cause.length > MAX_CAUSE_LENGTH
       ? `${cause.slice(0, MAX_CAUSE_LENGTH)}...`
       : cause;
   }
 
   try {
-    const str = String(cause);
+    // Handle objects with custom toString, otherwise use JSON
+    const str =
+      typeof cause === "object" && cause !== null
+        ? JSON.stringify(cause)
+        : String(cause as string | number | boolean);
     return str.length > MAX_CAUSE_LENGTH
       ? `${str.slice(0, MAX_CAUSE_LENGTH)}...`
       : str;
   } catch {
-    return '[unserializable cause]';
+    return "[unserializable cause]";
   }
 }
 
@@ -80,7 +84,7 @@ function normalizeCause(
  */
 export function llmError(
   code: LlmErrorCode,
-  opts: Omit<LlmError, 'code'>
+  opts: Omit<LlmError, "code">
 ): LlmError {
   return {
     code,
@@ -94,10 +98,10 @@ export function llmError(
  */
 export function isRetryable(code: LlmErrorCode): boolean {
   return [
-    'MODEL_DOWNLOAD_FAILED',
-    'TIMEOUT',
-    'INFERENCE_FAILED',
-    'LOCK_FAILED',
+    "MODEL_DOWNLOAD_FAILED",
+    "TIMEOUT",
+    "INFERENCE_FAILED",
+    "LOCK_FAILED",
   ].includes(code);
 }
 
@@ -106,7 +110,7 @@ export function isRetryable(code: LlmErrorCode): boolean {
 // ─────────────────────────────────────────────────────────────────────────────
 
 export function modelNotFoundError(uri: string, details?: string): LlmError {
-  return llmError('MODEL_NOT_FOUND', {
+  return llmError("MODEL_NOT_FOUND", {
     message: details
       ? `Model not found: ${details}`
       : `Model not found: ${uri}`,
@@ -117,9 +121,9 @@ export function modelNotFoundError(uri: string, details?: string): LlmError {
 
 export function modelNotCachedError(
   uri: string,
-  modelType: 'embed' | 'rerank' | 'gen'
+  modelType: "embed" | "rerank" | "gen"
 ): LlmError {
-  return llmError('MODEL_NOT_CACHED', {
+  return llmError("MODEL_NOT_CACHED", {
     message: `${modelType} model not cached`,
     modelUri: uri,
     retryable: false,
@@ -128,7 +132,7 @@ export function modelNotCachedError(
 }
 
 export function downloadFailedError(uri: string, cause?: unknown): LlmError {
-  return llmError('MODEL_DOWNLOAD_FAILED', {
+  return llmError("MODEL_DOWNLOAD_FAILED", {
     message: `Failed to download model: ${uri}`,
     modelUri: uri,
     retryable: true,
@@ -137,27 +141,27 @@ export function downloadFailedError(uri: string, cause?: unknown): LlmError {
 }
 
 export function loadFailedError(uri: string, cause?: unknown): LlmError {
-  return llmError('MODEL_LOAD_FAILED', {
+  return llmError("MODEL_LOAD_FAILED", {
     message: `Failed to load model: ${uri}`,
     modelUri: uri,
     retryable: false,
     cause,
-    suggestion: 'Run: gno doctor',
+    suggestion: "Run: gno doctor",
   });
 }
 
 export function corruptedError(uri: string, cause?: unknown): LlmError {
-  return llmError('MODEL_CORRUPTED', {
+  return llmError("MODEL_CORRUPTED", {
     message: `Model file corrupted: ${uri}`,
     modelUri: uri,
     retryable: false,
     cause,
-    suggestion: 'Run: gno models clear && gno models pull',
+    suggestion: "Run: gno models clear && gno models pull",
   });
 }
 
 export function inferenceFailedError(uri: string, cause?: unknown): LlmError {
-  return llmError('INFERENCE_FAILED', {
+  return llmError("INFERENCE_FAILED", {
     message: `Inference failed for model: ${uri}`,
     modelUri: uri,
     retryable: true,
@@ -167,10 +171,10 @@ export function inferenceFailedError(uri: string, cause?: unknown): LlmError {
 
 export function timeoutError(
   uri: string,
-  operation: 'load' | 'inference',
+  operation: "load" | "inference",
   timeoutMs: number
 ): LlmError {
-  return llmError('TIMEOUT', {
+  return llmError("TIMEOUT", {
     message: `${operation} timed out after ${timeoutMs}ms`,
     modelUri: uri,
     retryable: true,
@@ -178,17 +182,17 @@ export function timeoutError(
 }
 
 export function outOfMemoryError(uri: string, cause?: unknown): LlmError {
-  return llmError('OUT_OF_MEMORY', {
+  return llmError("OUT_OF_MEMORY", {
     message: `Out of memory loading model: ${uri}`,
     modelUri: uri,
     retryable: false,
     cause,
-    suggestion: 'Try a smaller quantization (Q4_K_M) or close other apps',
+    suggestion: "Try a smaller quantization (Q4_K_M) or close other apps",
   });
 }
 
 export function invalidUriError(uri: string, details: string): LlmError {
-  return llmError('INVALID_URI', {
+  return llmError("INVALID_URI", {
     message: `Invalid model URI: ${details}`,
     modelUri: uri,
     retryable: false,
@@ -196,16 +200,16 @@ export function invalidUriError(uri: string, details: string): LlmError {
 }
 
 export function lockFailedError(uri: string): LlmError {
-  return llmError('LOCK_FAILED', {
+  return llmError("LOCK_FAILED", {
     message: `Failed to acquire lock for model download: ${uri}`,
     modelUri: uri,
     retryable: true,
-    suggestion: 'Another process may be downloading. Wait and retry.',
+    suggestion: "Another process may be downloading. Wait and retry.",
   });
 }
 
 export function autoDownloadDisabledError(uri: string): LlmError {
-  return llmError('AUTO_DOWNLOAD_DISABLED', {
+  return llmError("AUTO_DOWNLOAD_DISABLED", {
     message: `Model not cached and auto-download disabled: ${uri}`,
     modelUri: uri,
     retryable: false,

package/src/llm/index.ts

@@ -5,12 +5,12 @@
  */
 
 // Re-export config types (source of truth in config/types.ts)
-export type { ModelConfig, ModelPreset } from '../config/types';
-export type { ParsedModelUri } from './cache';
+export type { ModelConfig, ModelPreset } from "../config/types";
+export type { ParsedModelUri } from "./cache";
 // Cache
-export { ModelCache, parseModelUri, toNodeLlamaCppUri } from './cache';
+export { ModelCache, parseModelUri, toNodeLlamaCppUri } from "./cache";
 // Errors
-export type { LlmError, LlmErrorCode } from './errors';
+export type { LlmError, LlmErrorCode } from "./errors";
 export {
   corruptedError,
   downloadFailedError,
@@ -23,15 +23,15 @@ export {
   modelNotFoundError,
   outOfMemoryError,
   timeoutError,
-} from './errors';
+} from "./errors";
 // Adapter
-export { createLlmAdapter, LlmAdapter } from './nodeLlamaCpp/adapter';
+export { createLlmAdapter, LlmAdapter } from "./nodeLlamaCpp/adapter";
 // Lifecycle
 export {
   getModelManager,
   ModelManager,
   resetModelManager,
-} from './nodeLlamaCpp/lifecycle';
+} from "./nodeLlamaCpp/lifecycle";
 // Registry
 export {
   getActivePreset,
@@ -39,7 +39,7 @@ export {
   getPreset,
   listPresets,
   resolveModelUri,
-} from './registry';
+} from "./registry";
 // Types
 export type {
   DownloadProgress,
@@ -55,4 +55,4 @@ export type {
   ProgressCallback,
   RerankPort,
   RerankScore,
-} from './types';
+} from "./types";

package/src/llm/lockfile.ts

@@ -5,11 +5,11 @@
  * @module src/llm/lockfile
  */
 
-import { open, rename, rm, stat } from 'node:fs/promises';
+import { open, rename, rm, stat } from "node:fs/promises";
 // node:os: hostname and user for lock ownership
-import { hostname, userInfo } from 'node:os';
+import { hostname, userInfo } from "node:os";
 // node:path: join for manifest lock path
-import { join } from 'node:path';
+import { join } from "node:path";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Constants
@@ -101,7 +101,7 @@ async function createLockExclusive(
   const content = JSON.stringify(meta, null, 2);
 
   // Create lock file with O_EXCL - fails if exists
-  const fh = await open(lockPath, 'wx');
+  const fh = await open(lockPath, "wx");
   try {
     await fh.writeFile(content);
     await fh.sync();
@@ -147,7 +147,7 @@ export async function acquireLock(
       };
     } catch (e) {
       // EEXIST means lock exists
-      if (e && typeof e === 'object' && 'code' in e && e.code === 'EEXIST') {
+      if (e && typeof e === "object" && "code" in e && e.code === "EEXIST") {
         // Check if stale
         const stale = await isLockStale(lockPath, ttlMs);
 
@@ -212,5 +212,5 @@ export function getLockPath(modelPath: string): string {
  * Get the manifest lock path for a cache directory.
  */
 export function getManifestLockPath(cacheDir: string): string {
-  return join(cacheDir, 'manifest.lock');
+  return join(cacheDir, "manifest.lock");
 }

package/src/llm/nodeLlamaCpp/adapter.ts

@@ -5,21 +5,22 @@
  * @module src/llm/nodeLlamaCpp/adapter
  */
 
-import type { Config } from '../../config/types';
-import { ModelCache } from '../cache';
-import type { DownloadPolicy } from '../policy';
-import { getActivePreset, getModelConfig } from '../registry';
+import type { Config } from "../../config/types";
+import type { DownloadPolicy } from "../policy";
 import type {
   EmbeddingPort,
   GenerationPort,
   LlmResult,
   ProgressCallback,
   RerankPort,
-} from '../types';
-import { NodeLlamaCppEmbedding } from './embedding';
-import { NodeLlamaCppGeneration } from './generation';
-import { getModelManager, type ModelManager } from './lifecycle';
-import { NodeLlamaCppRerank } from './rerank';
+} from "../types";
+
+import { ModelCache } from "../cache";
+import { getActivePreset, getModelConfig } from "../registry";
+import { NodeLlamaCppEmbedding } from "./embedding";
+import { NodeLlamaCppGeneration } from "./generation";
+import { getModelManager, type ModelManager } from "./lifecycle";
+import { NodeLlamaCppRerank } from "./rerank";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -66,7 +67,7 @@ export class LlmAdapter {
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,
-      'embed',
+      "embed",
       policy,
       options?.onProgress
     );
@@ -95,7 +96,7 @@ export class LlmAdapter {
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,
-      'gen',
+      "gen",
       policy,
       options?.onProgress
     );
@@ -124,7 +125,7 @@ export class LlmAdapter {
     // Ensure model is available (downloads if policy allows)
     const resolved = await this.cache.ensureModel(
       uri,
-      'rerank',
+      "rerank",
       policy,
       options?.onProgress
     );