@gmickel/gno 2.4.0 → 2.6.0

package/src/cli/commands/capture.ts

@@ -4,30 +4,28 @@
  * @module src/cli/commands/capture
  */
 
-// node:fs/promises for mkdir (no Bun equivalent for recursive dir creation)
-import { mkdir } from "node:fs/promises";
-// node:path has no Bun path utilities
-import { dirname, join } from "node:path";
-
 import type {
-  CapturePlan,
+  CaptureInput,
   CaptureReceipt,
   CaptureSourceKind,
 } from "../../core/capture";
 import type { NoteCollisionPolicy } from "../../core/note-creation";
 import type { NotePresetId } from "../../core/note-presets";
+import type { RequestReceiptInfo } from "../../core/request-receipts";
 
 import { getIndexDbPath } from "../../app/constants";
 import {
-  buildCaptureReceipt,
   listCaptureDiskRelPaths,
   planCapture,
   serializeCaptureReceipt,
 } from "../../core/capture";
-import { writeCapturePlanFile } from "../../core/capture-write";
-import { withWriteLock } from "../../core/file-lock";
-import { defaultSyncService, withContentTypeRules } from "../../ingestion";
+import { publishCapture } from "../../core/capture-publish";
+import {
+  formatRequestReceiptLine,
+  localRequestLedger,
+} from "../../core/request-receipts";
 import { CliError } from "../errors";
+import { requestErrorToCli } from "./request-status";
 import { initStore } from "./shared";
 
 export interface CaptureCliOptions {
@@ -49,6 +47,7 @@ export interface CaptureCliOptions {
   sourceAuthor?: string;
   sourceDate?: string;
   sourceId?: string;
+  requestId?: string;
 }
 
 const SOURCE_KINDS = new Set<CaptureSourceKind>([
@@ -130,7 +129,7 @@ function validateCollisionPolicy(
 
 export async function capture(
   options: CaptureCliOptions
-): Promise<CaptureReceipt> {
+): Promise<CaptureReceipt & { request?: RequestReceiptInfo }> {
   const storeInit = await initStore({
     configPath: options.configPath,
     indexName: options.indexName,
@@ -160,102 +159,61 @@ export async function capture(
 
     validateCollisionPolicy(options.collisionPolicy);
     const content = await readContent(options);
-    const existingDocs = await store.listDocuments(collection.name);
-    if (!existingDocs.ok) {
-      throw new Error(existingDocs.error.message);
-    }
-    const diskRelPaths = await listCaptureDiskRelPaths(collection.path);
-    let plan: CapturePlan;
+    const input: CaptureInput = {
+      collection: collection.name,
+      content,
+      title: options.title,
+      relPath: options.path,
+      folderPath: options.folder,
+      collisionPolicy: options.collisionPolicy,
+      presetId: options.preset,
+      tags: parseTags(options.tags),
+      source: buildSource(options),
+    };
+    const ledger = localRequestLedger(getIndexDbPath(options.indexName));
     try {
-      plan = planCapture({
-        input: {
-          collection: collection.name,
-          content,
-          title: options.title,
-          relPath: options.path,
-          folderPath: options.folder,
-          collisionPolicy: options.collisionPolicy,
-          presetId: options.preset,
-          tags: parseTags(options.tags),
-          source: buildSource(options),
+      const published = await publishCapture({
+        collection,
+        store,
+        lockPath: ledger.lockPath,
+        reportSyncFailure: true,
+        config,
+        plan: async () => {
+          const existingDocs = await store.listDocuments(collection.name);
+          if (!existingDocs.ok) {
+            throw new Error(existingDocs.error.message);
+          }
+          try {
+            return planCapture({
+              input,
+              existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
+              diskRelPaths: await listCaptureDiskRelPaths(collection.path),
+            });
+          } catch (error) {
+            throw new CliError(
+              "VALIDATION",
+              error instanceof Error ? error.message : String(error)
+            );
+          }
         },
-        existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
-        diskRelPaths,
+        request:
+          options.requestId === undefined
+            ? undefined
+            : { ...ledger, requestId: options.requestId, input },
       });
+      return published.request
+        ? { ...published.receipt, request: published.request }
+        : published.receipt;
     } catch (error) {
-      throw new CliError(
-        "VALIDATION",
-        error instanceof Error ? error.message : String(error)
-      );
+      throw requestErrorToCli(error);
     }
-    const absPath = join(collection.path, plan.relPath);
-
-    const lockPath = join(
-      dirname(getIndexDbPath(options.indexName)),
-      ".mcp-write.lock"
-    );
-    return await withWriteLock(lockPath, async () => {
-      if (plan.openedExisting) {
-        const existingDoc = await store.getDocument(
-          collection.name,
-          plan.relPath
-        );
-        if (!existingDoc.ok) {
-          throw new Error(existingDoc.error.message);
-        }
-        return buildCaptureReceipt({
-          plan,
-          absPath,
-          docid: existingDoc.value?.docid,
-          sync: existingDoc.value
-            ? { status: "completed" }
-            : {
-                status: "skipped",
-                reason: "Existing file is not indexed yet.",
-              },
-        });
-      }
-
-      await mkdir(dirname(absPath), { recursive: true });
-      await writeCapturePlanFile(plan, absPath);
-      const syncResults = await defaultSyncService.syncFiles(
-        collection,
-        store,
-        [plan.relPath],
-        withContentTypeRules(
-          {
-            runUpdateCmd: false,
-            gitPull: false,
-          },
-          config
-        )
-      );
-      const syncResult = syncResults[0];
-      const docResult = await store.getDocument(collection.name, plan.relPath);
-      const docid = docResult.ok ? docResult.value?.docid : undefined;
-      return buildCaptureReceipt({
-        plan,
-        absPath,
-        docid: syncResult?.docid ?? docid,
-        sync:
-          syncResult?.status === "error"
-            ? {
-                status: "failed",
-                error:
-                  syncResult.errorMessage ??
-                  syncResult.errorCode ??
-                  "Unknown sync error",
-              }
-            : { status: "completed" },
-      });
-    });
   } finally {
     await store.close();
   }
 }
 
 export function formatCaptureReceipt(
-  receipt: CaptureReceipt,
+  receipt: CaptureReceipt & { request?: RequestReceiptInfo },
   options: { json?: boolean; quiet?: boolean } = {}
 ): string {
   if (options.json) {
@@ -278,5 +236,6 @@ export function formatCaptureReceipt(
   if (receipt.source.url) {
     lines.push(`Source: ${receipt.source.url}`);
   }
+  if (receipt.request) lines.push(formatRequestReceiptLine(receipt.request));
   return lines.join("\n");
 }

package/src/cli/commands/context-compiled.ts

@@ -0,0 +1,136 @@
+import { previewCompiledContext } from "../../app/compiled-context";
+import {
+  compileContextFile,
+  checkContextFile,
+  refreshContextFile,
+} from "../../app/compiled-context-files";
+/** Explicit local compiled context operations. */
+import { createGnoClient } from "../../sdk/client";
+import { CliError } from "../errors";
+import { contextCliError } from "./context-build";
+import { initStore } from "./shared";
+
+export interface CompiledCommandOptions {
+  configPath?: string;
+  indexName?: string;
+  capsulePath?: string;
+  capsuleOutputPath?: string;
+  outputPath?: string;
+  budgetTokens?: number;
+  budgetBytes?: number;
+  json?: boolean;
+}
+
+export async function contextCompiled(
+  operation: "preview" | "compile" | "check" | "refresh",
+  options: CompiledCommandOptions
+): Promise<{
+  output: string;
+  status?: "current" | "stale" | "conflict" | "unverifiable";
+}> {
+  const initialized = await initStore({
+    configPath: options.configPath,
+    indexName: options.indexName,
+    syncConfig: false,
+    allowEmptyCollections: true,
+  });
+  if (!initialized.ok) throw new CliError("RUNTIME", initialized.error);
+  const deps = {
+    store: initialized.store,
+    config: initialized.config,
+    indexName: options.indexName,
+  };
+  try {
+    if (operation === "check") {
+      if (!options.outputPath)
+        throw new CliError("VALIDATION", "Artifact path required");
+      const result = await checkContextFile(
+        { outputPath: options.outputPath, capsulePath: options.capsulePath },
+        deps
+      );
+      return {
+        output: options.json
+          ? JSON.stringify(result)
+          : `${result.status}: ${result.reasons.join("; ") || "verified current"}`,
+        status: result.status,
+      };
+    }
+    if (operation === "refresh") {
+      if (!options.outputPath || !options.capsuleOutputPath)
+        throw new CliError(
+          "VALIDATION",
+          "Artifact and Capsule output paths required"
+        );
+      const result = await refreshContextFile(
+        {
+          outputPath: options.outputPath,
+          capsuleOutputPath: options.capsuleOutputPath,
+        },
+        deps,
+        async (request) => {
+          const client = await createGnoClient({
+            configPath: options.configPath,
+            indexName: options.indexName,
+          });
+          try {
+            return await client.context(request);
+          } finally {
+            await client.close();
+          }
+        }
+      );
+      return {
+        output: options.json
+          ? JSON.stringify(result)
+          : `${result.status}: ${result.outputPath}`,
+      };
+    }
+    if (!options.capsulePath || !options.budgetTokens)
+      throw new CliError("VALIDATION", "Capsule path and budget required");
+    if (operation === "compile") {
+      if (!options.outputPath)
+        throw new CliError("VALIDATION", "Output path required");
+      const result = await compileContextFile(
+        {
+          capsulePath: options.capsulePath,
+          outputPath: options.outputPath,
+          budgetTokens: options.budgetTokens,
+          budgetBytes: options.budgetBytes,
+        },
+        deps
+      );
+      return {
+        output: options.json
+          ? JSON.stringify(result)
+          : `${result.status}: ${result.outputPath}`,
+      };
+    }
+    const source = Bun.file(options.capsulePath);
+    if (source.size > 4 * 1024 * 1024)
+      throw new CliError("VALIDATION", "Capsule exceeds byte limit");
+    const capsule: unknown = await source.json();
+    const result = await previewCompiledContext(
+      {
+        capsule,
+        budgetTokens: options.budgetTokens,
+        budgetBytes: options.budgetBytes,
+      },
+      deps
+    );
+    return { output: options.json ? JSON.stringify(result) : result.markdown };
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    if (
+      error instanceof SyntaxError ||
+      (error instanceof Error && error.name === "ZodError")
+    ) {
+      throw new CliError(
+        "VALIDATION",
+        "Invalid compiled context input; provide a valid Capsule and budget"
+      );
+    }
+    throw contextCliError(error);
+  } finally {
+    await initialized.store.close();
+  }
+}

package/src/cli/commands/daemon.ts

@@ -3,6 +3,7 @@ import type { HttpGatewayOverrides } from "../../mcp/http-security";
 import type { BackgroundRuntimeResult } from "../../serve/background-runtime";
 import type { FindingsPassResult } from "../../serve/findings-pass";
 import type { ResidentRuntime } from "../../serve/resident-runtime";
+import type { SessionAutomationRunResult } from "../../sessions/types";
 
 import {
   enforceCollectionEgress,
@@ -17,6 +18,7 @@ import {
 import { startBackgroundRuntime } from "../../serve/background-runtime";
 import { handleResidentStatus, handleStatus } from "../../serve/routes/api";
 import { createMcpHttpGateway } from "../../serve/routes/mcp";
+import { SessionsError } from "../../sessions/types";
 
 export interface DaemonOptions extends HttpGatewayOverrides {
   configPath?: string;
@@ -67,6 +69,31 @@ export function logFindingsPassResult(
   );
 }
 
+/** Content-free: counts and reason codes only; clean no-ops stay silent. */
+export function logSessionAutomationResult(
+  result: SessionAutomationRunResult,
+  logger: DaemonLogger,
+  options: { quiet?: boolean }
+): void {
+  if (!result.ran) return;
+  if (result.outcome === "failed") {
+    logger.error(
+      `session automation ${result.profileId}: failed (${result.reason ?? "unknown"})`
+    );
+    return;
+  }
+  if (result.outcome === "up_to_date" || options.quiet) return;
+  let imported = 0;
+  let updated = 0;
+  for (const receipt of result.receipts) {
+    imported += receipt.counts.imported;
+    updated += receipt.counts.updated;
+  }
+  logger.log(
+    `session automation ${result.profileId}: ${result.outcome}${result.reason ? ` (${result.reason})` : ""}; ${imported} threads imported, ${updated} updated`
+  );
+}
+
 function formatCollectionSyncSummary(result: CollectionSyncResult): string {
   return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
 }
@@ -175,6 +202,20 @@ export async function daemon(
         quiet: options.quiet,
         verbose: options.verbose,
       }),
+    onSessionAutomationResult: (result) =>
+      logSessionAutomationResult(result, logger, { quiet: options.quiet }),
+    onSessionAutomationError: (error) => {
+      // Busy state (a run or state change in progress) is retried next tick.
+      if (error instanceof SessionsError && error.code === "SESSIONS_BUSY") {
+        if (options.verbose) {
+          logger.log("session automation: run in progress; next tick retries");
+        }
+        return;
+      }
+      logger.error(
+        `session automation tick failed: ${error instanceof SessionsError ? error.code : "runtime error"}`
+      );
+    },
     watchCallbacks: {
       onSyncStart: ({ collection, relPaths }) => {
         if (!options.quiet) {

package/src/cli/commands/ls.ts

@@ -14,6 +14,8 @@ import { initStore } from "./shared";
 // ─────────────────────────────────────────────────────────────────────────────
 
 export interface LsCommandOptions {
+  /** Index name (defaults to "default"). */
+  indexName?: string;
   /** Override config path */
   configPath?: string;
   /** Max results (default 20) */
@@ -111,6 +113,7 @@ export async function ls(
 
   const initResult = await initStore({
     configPath: options.configPath,
+    indexName: options.indexName,
     syncConfig: false,
   });
   if (!initResult.ok) {

package/src/cli/commands/memory.ts

@@ -24,11 +24,15 @@ import {
   type RememberInput,
   type RememberResult,
 } from "../../core/memory";
-import { writeLeasePath } from "../../core/write-lease";
+import {
+  formatRequestReceiptLine,
+  localRequestLedger,
+} from "../../core/request-receipts";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveModelUri } from "../../llm/registry";
 import { createVectorIndexPort } from "../../store/vector";
 import { CliError, type CliErrorCode } from "../errors";
+import { requestErrorToCli } from "./request-status";
 import { initStore } from "./shared";
 
 /** Environment overrides for the identity defaults. */
@@ -62,6 +66,7 @@ export interface RememberCliOptions
   receipt?: string;
   derivedFrom?: string[];
   source?: string;
+  requestId?: string;
 }
 
 export interface RecallCliOptions
@@ -254,7 +259,7 @@ const MEMORY_ERROR_TO_CLI: Record<MemoryErrorCode, CliErrorCode> = {
 
 /** Map a core `MemoryError` onto the CLI error model (code carried in details). */
 export function toCliError(error: unknown): unknown {
-  if (!(error instanceof MemoryError)) return error;
+  if (!(error instanceof MemoryError)) return requestErrorToCli(error);
   return new CliError(MEMORY_ERROR_TO_CLI[error.code], error.message, {
     details: { memoryCode: error.code },
   });
@@ -322,11 +327,13 @@ async function openMemoryRuntime(
         await embedResult.value.dispose();
       }
     }
+    const ledger = localRequestLedger(getIndexDbPath(options.indexName));
     const service = new MemoryService({
       store,
       config,
       collections,
-      lockPath: writeLeasePath(getIndexDbPath(options.indexName)),
+      lockPath: ledger.lockPath,
+      requests: ledger,
       embedPort,
       vectorIndex,
     });
@@ -361,6 +368,7 @@ export async function remember(
         ? options.derivedFrom
         : undefined,
       source: options.source,
+      requestId: options.requestId,
     };
     return await runtime.service.remember(input);
   } catch (error) {
@@ -457,6 +465,7 @@ export function formatRememberResult(
     lines.push(`Sync: ${result.sync.status}`);
   }
   lines.push(`Matching: ${formatMatching(result.matching)}`);
+  if (result.request) lines.push(formatRequestReceiptLine(result.request));
   return lines.join("\n");
 }
 

package/src/cli/commands/request-status.ts

@@ -0,0 +1,59 @@
+/**
+ * gno request-status: look up a write request ID before retrying it, plus
+ * the CLI mapping for request receipt errors.
+ *
+ * @module src/cli/commands/request-status
+ */
+
+import { getIndexDbPath } from "../../app/constants";
+import {
+  formatRequestStatus,
+  localRequestLedger,
+  readRequestStatus,
+  RequestReceiptError,
+  type RequestReceiptErrorCode,
+  type RequestStatusResult,
+} from "../../core/request-receipts";
+import { CliError, type CliErrorCode } from "../errors";
+
+const REQUEST_ERROR_TO_CLI: Record<RequestReceiptErrorCode, CliErrorCode> = {
+  REQUEST_ID_INVALID: "VALIDATION",
+  REQUEST_ID_CONFLICT: "VALIDATION",
+  REQUEST_EXPIRED: "VALIDATION",
+  // Accepted and still in progress elsewhere: exit 4 like lease contention.
+  REQUEST_PENDING: "BUSY",
+  REQUEST_RECOVERY_CONFLICT: "RUNTIME",
+  REQUEST_CAPACITY_EXHAUSTED: "RUNTIME",
+  REQUEST_LEDGER_UNAVAILABLE: "RUNTIME",
+};
+
+/** Map a request receipt error onto the CLI error model (code in details). */
+export function requestErrorToCli(error: unknown): unknown {
+  if (!(error instanceof RequestReceiptError)) return error;
+  return new CliError(REQUEST_ERROR_TO_CLI[error.code], error.message, {
+    details: { requestCode: error.code },
+  });
+}
+
+export async function requestStatus(options: {
+  requestId: string;
+  indexName?: string;
+}): Promise<RequestStatusResult> {
+  try {
+    return await readRequestStatus({
+      ...localRequestLedger(getIndexDbPath(options.indexName)),
+      requestId: options.requestId,
+    });
+  } catch (error) {
+    throw requestErrorToCli(error);
+  }
+}
+
+export function formatRequestStatusOutput(
+  result: RequestStatusResult,
+  options: { json?: boolean } = {}
+): string {
+  return options.json
+    ? JSON.stringify(result, null, 2)
+    : formatRequestStatus(result);
+}

package/src/cli/commands/reset.ts

@@ -1,17 +1,20 @@
 /**
  * gno reset - Reset GNO to fresh state
  *
- * Deletes all config, data, and cache directories.
+ * Deletes all config, data, and cache directories. The request ledger
+ * (`<dataDir>/write-receipts/`) is kept so request IDs that already ran
+ * can never run again.
  */
 
 // node:fs/promises: rm and stat for recursive directory deletion (no Bun equivalent)
-import { rm, stat } from "node:fs/promises";
+import { readdir, rm, stat } from "node:fs/promises";
 // node:os: homedir for platform-agnostic home directory (no Bun equivalent)
 import { homedir } from "node:os";
 // node:path: path manipulation utilities (no Bun equivalent)
-import { isAbsolute, normalize, sep } from "node:path";
+import { isAbsolute, join, normalize, sep } from "node:path";
 
 import { resolveDirs } from "../../app/constants";
+import { REQUEST_LEDGER_DIR } from "../../core/request-receipts";
 import { CliError } from "../errors";
 
 interface ResetOptions {
@@ -103,8 +106,8 @@ export async function reset(options: ResetOptions): Promise<ResetResult> {
     assertSafePath(dirs.cache, "Cache");
   }
 
-  // Delete data directory (always, contains index DB)
-  results.push(await rmDir(dirs.data));
+  // Empty the data directory (index DBs, caches) but keep the request ledger.
+  results.push(...(await clearDataDir(dirs.data)));
 
   // Delete config unless --keep-config
   if (options.keepConfig) {
@@ -134,6 +137,37 @@ export async function reset(options: ResetOptions): Promise<ResetResult> {
   return { results, errors };
 }
 
+/** Empty the data directory except the request ledger (what reset runs). */
+export async function clearDataDir(path: string): Promise<DirResult[]> {
+  let entries: string[];
+  try {
+    entries = await readdir(path);
+  } catch (e) {
+    const err = e as NodeJS.ErrnoException;
+    return [
+      err.code === "ENOENT"
+        ? { path, status: "missing" }
+        : { path, status: "missing", error: err.message },
+    ];
+  }
+  if (!entries.includes(REQUEST_LEDGER_DIR)) return [await rmDir(path)];
+  const failures: string[] = [];
+  for (const entry of entries) {
+    if (entry === REQUEST_LEDGER_DIR) continue;
+    try {
+      await rm(join(path, entry), { recursive: true, force: true });
+    } catch (e) {
+      failures.push(`${entry}: ${(e as Error).message}`);
+    }
+  }
+  return [
+    failures.length > 0
+      ? { path, status: "missing", error: failures.join("; ") }
+      : { path, status: "deleted" },
+    { path: join(path, REQUEST_LEDGER_DIR), status: "kept" },
+  ];
+}
+
 async function rmDir(path: string): Promise<DirResult> {
   try {
     // Check if exists first