@gmickel/gno 1.1.0 → 1.2.1

package/src/cli/run.ts

@@ -169,7 +169,10 @@ Run '${CLI_NAME} --help' for full command list.
  * No process.exit() - caller sets process.exitCode.
  */
 export async function runCli(argv: string[]): Promise<number> {
-  // Reset global state for clean invocation (important for testing)
+  // Reset global state for clean invocation (important for testing).
+  // The detach paths (runServeDetach / runDaemonDetach) read argv from
+  // Commander's per-invocation `Command.rawArgs` via `resolveCliArgv()`,
+  // so no separate process-global capture is needed here.
   resetGlobals();
 
   const isJson = argvWantsJson(argv);
@@ -204,8 +207,13 @@ export async function runCli(argv: string[]): Promise<number> {
   } catch (err) {
     // Handle CliError with proper JSON formatting
     if (err instanceof CliError) {
-      const output = formatErrorForOutput(err, { json: isJson });
-      process.stderr.write(`${output}\n`);
+      // `silent` is reserved for codes whose exit value carries the meaning
+      // (e.g. NOT_RUNNING from `--stop` per spec/cli.md). Skip stderr but
+      // still propagate the code.
+      if (!err.silent) {
+        const output = formatErrorForOutput(err, { json: isJson });
+        process.stderr.write(`${output}\n`);
+      }
       return exitCodeFor(err);
     }
 

package/src/llm/cache.ts

@@ -41,6 +41,27 @@ import { getLockPath, getManifestLockPath, withLock } from "./lockfile";
 const HF_QUANT_PATTERN = /^([^/]+)\/([^/:]+):(\w+)$/;
 const HF_PATH_PATTERN = /^([^/]+)\/([^/]+)\/(.+\.gguf)$/;
 
+async function computeSha256(path: string): Promise<string> {
+  const hasher = new Bun.CryptoHasher("sha256");
+  const reader = Bun.file(path).stream().getReader();
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        hasher.update(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  return hasher.digest("hex");
+}
+
 export type ParsedModelUri =
   | {
       scheme: "hf";
@@ -588,6 +609,7 @@ export class ModelCache {
   ): Promise<void> {
     // Get file size outside lock (IO-bound, doesn't need protection)
     let size = 0;
+    let checksum = "";
     try {
       const stats = await stat(modelPath);
       size = stats.size;
@@ -595,6 +617,12 @@ export class ModelCache {
       // Ignore
     }
 
+    try {
+      checksum = await computeSha256(modelPath);
+    } catch {
+      // Best-effort metadata only
+    }
+
     await this.updateManifest((manifest) => {
       // Remove existing entry if present
       manifest.models = manifest.models.filter((m) => m.uri !== uri);
@@ -605,7 +633,7 @@ export class ModelCache {
         type,
         path: modelPath,
         size,
-        checksum: "", // TODO: compute SHA-256 for large files
+        checksum,
         cachedAt: new Date().toISOString(),
       });
     });

package/src/llm/lockfile.ts

@@ -5,7 +5,7 @@
  * @module src/llm/lockfile
  */
 
-import { open, rename, rm, stat } from "node:fs/promises";
+import { open, readFile, rename, rm, stat } from "node:fs/promises";
 // node:os: hostname and user for lock ownership
 import { hostname, userInfo } from "node:os";
 // node:path: join for manifest lock path
@@ -68,6 +68,48 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function readLockMeta(lockPath: string): Promise<LockMeta | null> {
+  try {
+    const parsed = JSON.parse(
+      await readFile(lockPath, "utf-8")
+    ) as Partial<LockMeta>;
+    if (
+      typeof parsed.pid !== "number" ||
+      typeof parsed.hostname !== "string" ||
+      typeof parsed.user !== "string" ||
+      typeof parsed.createdAt !== "string"
+    ) {
+      return null;
+    }
+    return {
+      pid: parsed.pid,
+      hostname: parsed.hostname,
+      user: parsed.user,
+      createdAt: parsed.createdAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (
+      error !== null &&
+      typeof error === "object" &&
+      "code" in error &&
+      error.code === "EPERM"
+    );
+  }
+}
+
 /**
  * Check if a lockfile is stale (older than TTL or owner process dead).
  */
@@ -81,9 +123,12 @@ async function isLockStale(lockPath: string, ttlMs: number): Promise<boolean> {
       return true;
     }
 
-    // TODO: Could also check if PID is alive on same hostname
-    // For now, just use TTL-based staleness
-    return false;
+    const meta = await readLockMeta(lockPath);
+    if (!meta || meta.hostname !== hostname()) {
+      return false;
+    }
+
+    return !isProcessAlive(meta.pid);
   } catch {
     // Lock doesn't exist or can't be read
     return true;

package/src/pipeline/search.ts

@@ -15,6 +15,7 @@ import type {
   SearchResults,
 } from "./types";
 
+import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { matchesExcludedChunks, matchesExcludedText } from "./exclude";
@@ -277,14 +278,21 @@ export async function searchBm25(
     const sortedEntries = [...bestByDocid.values()].sort(
       (a, b) => a.score - b.score
     );
+    const fullContentResult = await getContentBatch(
+      store,
+      sortedEntries
+        .map(({ fts }) => fts.mirrorHash)
+        .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+    );
+    if (!fullContentResult.ok) {
+      return err("QUERY_FAILED", fullContentResult.error.message);
+    }
+    const fullContentByHash = fullContentResult.value;
+
     for (const { fts, chunk } of sortedEntries) {
-      let fullContent: string | undefined;
-      if (fts.mirrorHash) {
-        const contentResult = await store.getContent(fts.mirrorHash);
-        if (contentResult.ok && contentResult.value) {
-          fullContent = contentResult.value;
-        }
-      }
+      const fullContent = fts.mirrorHash
+        ? fullContentByHash.get(fts.mirrorHash)
+        : undefined;
       const collectionPath = fts.collection
         ? collectionPaths.get(fts.collection)
         : undefined;

package/src/pipeline/vsearch.ts

@@ -11,6 +11,7 @@ import type { StorePort } from "../store/types";
 import type { VectorIndexPort } from "../store/vector/types";
 import type { SearchOptions, SearchResult, SearchResults } from "./types";
 
+import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { formatQueryForEmbedding } from "./contextual";
@@ -249,14 +250,21 @@ export async function searchVectorWithEmbedding(
 
   // For --full, fetch full content and build results
   if (options.full) {
+    const fullContentResult = await getContentBatch(
+      store,
+      [...bestByDocid.values()]
+        .map(({ doc }) => doc.mirrorHash)
+        .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+    );
+    if (!fullContentResult.ok) {
+      return err("QUERY_FAILED", fullContentResult.error.message);
+    }
+    const fullContentByHash = fullContentResult.value;
+
     for (const { doc, chunk, score } of bestByDocid.values()) {
-      let fullContent: string | undefined;
-      if (doc.mirrorHash) {
-        const contentResult = await store.getContent(doc.mirrorHash);
-        if (contentResult.ok && contentResult.value) {
-          fullContent = contentResult.value;
-        }
-      }
+      const fullContent = doc.mirrorHash
+        ? fullContentByHash.get(doc.mirrorHash)
+        : undefined;
 
       const collectionPath = collectionPaths.get(doc.collection);
 

package/src/publish/export-service.ts

@@ -9,6 +9,7 @@ import type { DocumentRow, StorePort, TagRow } from "../store/types";
 
 import { parseRef } from "../cli/commands/ref-parser";
 import { parseFrontmatter } from "../ingestion/frontmatter";
+import { getContentBatch } from "../store/content-batch";
 import {
   buildEncryptedPublishArtifact,
   buildPublishArtifact,
@@ -155,16 +156,40 @@ async function exportCollectionArtifact(
     throw new Error(`Collection "${collection.name}" has no active documents`);
   }
 
+  const contentResult = await getContentBatch(
+    store,
+    activeDocs
+      .map((doc) => doc.mirrorHash)
+      .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+  );
+  if (!contentResult.ok) {
+    throw new Error(contentResult.error.message);
+  }
+
+  const tagsResult = await store.getTagsBatch(activeDocs.map((doc) => doc.id));
+  if (!tagsResult.ok) {
+    throw new Error(tagsResult.error.message);
+  }
+
+  const contentByHash = contentResult.value;
+  const tagsByDocId = tagsResult.value;
+
   const notes: PublishArtifactNote[] = [];
   for (const doc of activeDocs) {
-    const rawMarkdown = await loadDocumentMarkdown(store, doc);
+    if (!doc.mirrorHash) {
+      throw new Error(`Document has no converted content: ${doc.uri}`);
+    }
+    const rawMarkdown = contentByHash.get(doc.mirrorHash);
+    if (rawMarkdown === undefined) {
+      throw new Error(`Unable to load content for ${doc.uri}`);
+    }
     if (isPublishDisabledByFrontmatter(rawMarkdown)) {
       continue;
     }
     const sanitized = sanitizeObsidianMarkdown(rawMarkdown);
     warnings.push(...sanitized.warnings);
     const markdown = sanitized.markdown;
-    const tags = await loadDocumentTags(store, doc);
+    const tags = tagsByDocId.get(doc.id) ?? [];
     const frontmatter = parseFrontmatter(markdown).metadata;
     const title = deriveExportedTitle(doc);
     notes.push({

package/src/store/content-batch.ts

@@ -0,0 +1,38 @@
+import type { StorePort, StoreResult } from "./types";
+
+import { err, ok } from "./types";
+
+/**
+ * Load content in batch when the store supports it.
+ * Falls back to sequential reads for lightweight test doubles.
+ */
+export async function getContentBatch(
+  store: StorePort,
+  mirrorHashes: string[]
+): Promise<StoreResult<Map<string, string>>> {
+  const uniqueHashes = [...new Set(mirrorHashes)];
+  if (uniqueHashes.length === 0) {
+    return ok(new Map());
+  }
+
+  if (store.getContentBatch) {
+    return store.getContentBatch(uniqueHashes);
+  }
+
+  const contentByHash = new Map<string, string>();
+  for (const mirrorHash of uniqueHashes) {
+    const contentResult = await store.getContent(mirrorHash);
+    if (!contentResult.ok) {
+      return err(
+        "QUERY_FAILED",
+        contentResult.error.message,
+        contentResult.error.cause
+      );
+    }
+    if (contentResult.value !== null) {
+      contentByHash.set(mirrorHash, contentResult.value);
+    }
+  }
+
+  return ok(contentByHash);
+}

package/src/store/sqlite/adapter.ts

@@ -1048,6 +1048,41 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async getContentBatch(
+    mirrorHashes: string[]
+  ): Promise<StoreResult<Map<string, string>>> {
+    try {
+      const db = this.ensureOpen();
+
+      if (mirrorHashes.length === 0) {
+        return ok(new Map());
+      }
+
+      interface DbContentRow {
+        mirror_hash: string;
+        markdown: string;
+      }
+
+      const placeholders = mirrorHashes.map(() => "?").join(", ");
+      const rows = db
+        .query<DbContentRow, string[]>(
+          `SELECT mirror_hash, markdown FROM content
+           WHERE mirror_hash IN (${placeholders})`
+        )
+        .all(...mirrorHashes);
+
+      return ok(
+        new Map(rows.map((row) => [row.mirror_hash, row.markdown] as const))
+      );
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to get content batch",
+        cause
+      );
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // Chunks
   // ─────────────────────────────────────────────────────────────────────────

package/src/store/types.ts

@@ -694,6 +694,14 @@ export interface StorePort {
    */
   getContent(mirrorHash: string): Promise<StoreResult<string | null>>;
 
+  /**
+   * Batch fetch markdown content for multiple mirror hashes.
+   * Returns a map of mirrorHash -> markdown for hashes that exist.
+   */
+  getContentBatch?(
+    mirrorHashes: string[]
+  ): Promise<StoreResult<Map<string, string>>>;
+
   // ─────────────────────────────────────────────────────────────────────────
   // Chunks
   // ─────────────────────────────────────────────────────────────────────────