@gmickel/gno 2.5.1 → 2.6.0

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