@gmickel/gno 1.43.0 → 1.44.0

package/src/cli/commands/changes.ts

@@ -9,12 +9,14 @@ import type {
   ListKnowledgeChangesInput,
 } from "../../core/knowledge-delta";
 import type { StorePort } from "../../store/types";
+import type { ChangesFollowLine, FollowChangesResult } from "./changes-follow";
 
 import {
   analyzeKnowledgeImpact,
   getKnowledgeDiff,
   listKnowledgeChanges,
 } from "../../core/knowledge-delta";
+import { followChanges, validateFollowCursor } from "./changes-follow";
 import { initStore } from "./shared";
 
 export interface KnowledgeDeltaCliContext {
@@ -82,6 +84,67 @@ export const impact = (
 ): Promise<KnowledgeDeltaServiceResult<KnowledgeImpactResult>> =>
   withStore(context, (store) => impactRead(store, ref, input));
 
+export interface ChangesFollowInput {
+  cursor?: string;
+  collection?: string;
+}
+
+/** Abort on SIGINT/SIGTERM so the stream ends cleanly after the current line. */
+const abortOnSignals = (): { signal: AbortSignal; dispose: () => void } => {
+  const controller = new AbortController();
+  const onSignal = (): void => controller.abort();
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  return {
+    signal: controller.signal,
+    dispose: (): void => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+    },
+  };
+};
+
+/**
+ * `gno changes --follow --jsonl`: stream journal events as JSON lines on
+ * stdout until a signal arrives or the resume cursor expires.
+ */
+export const changesFollow = async (
+  input: ChangesFollowInput,
+  context: KnowledgeDeltaCliContext = {},
+  emit: (line: ChangesFollowLine) => void = (line) => {
+    process.stdout.write(`${JSON.stringify(line)}\n`);
+  }
+): Promise<FollowChangesResult> => {
+  if (input.cursor !== undefined) {
+    const invalid = validateFollowCursor(input.cursor);
+    if (invalid) return { status: "error", error: invalid, isValidation: true };
+  }
+  const collection = input.collection?.trim();
+  if (input.collection !== undefined && !collection) {
+    return {
+      status: "error",
+      error: "collection cannot be empty",
+      isValidation: true,
+    };
+  }
+  const signals = abortOnSignals();
+  try {
+    const result = await withStore(context, async (store) => ({
+      success: true as const,
+      data: await followChanges(
+        store,
+        { cursor: input.cursor, collection, signal: signals.signal },
+        emit
+      ),
+    }));
+    return result.success
+      ? result.data
+      : { status: "error", error: result.error, isValidation: false };
+  } finally {
+    signals.dispose();
+  }
+};
+
 const json = (value: unknown): string => JSON.stringify(value, null, 2);
 
 export function formatChanges(

package/src/cli/commands/daemon.ts

@@ -1,6 +1,7 @@
 import type { CollectionSyncResult } from "../../ingestion";
 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 {
@@ -43,6 +44,29 @@ type DaemonDeps = {
   logger?: DaemonLogger;
 };
 
+/** Silent when clean: only failures, and non-empty writes when not quiet, reach the log. */
+export function logFindingsPassResult(
+  result: FindingsPassResult,
+  logger: DaemonLogger,
+  options: { quiet?: boolean; verbose?: boolean }
+): void {
+  if (result.outcome === "failed") {
+    logger.error(`findings pass failed: ${result.error ?? "unknown error"}`);
+    return;
+  }
+  if (result.outcome === "skipped_lease") {
+    if (options.verbose) logger.log(`findings pass skipped: ${result.error}`);
+    return;
+  }
+  const { counts } = result;
+  const changed =
+    counts.written + counts.reopened + counts.resolved + counts.deleted;
+  if (changed === 0 || options.quiet) return;
+  logger.log(
+    `findings pass: ${counts.written} new, ${counts.reopened} reopened, ${counts.resolved} resolved, ${counts.deleted} expired (${counts.open} open)`
+  );
+}
+
 function formatCollectionSyncSummary(result: CollectionSyncResult): string {
   return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
 }
@@ -146,6 +170,11 @@ export async function daemon(
     index: options.index,
     requireCollections: true,
     offline: options.offline,
+    onFindingsResult: (result) =>
+      logFindingsPassResult(result, logger, {
+        quiet: options.quiet,
+        verbose: options.verbose,
+      }),
     watchCallbacks: {
       onSyncStart: ({ collection, relPaths }) => {
         if (!options.quiet) {
@@ -230,6 +259,12 @@ export async function daemon(
           logger.error(`watch failed: ${failed.collection}: ${failed.reason}`);
         }
       }
+      const findings = (runtime as Partial<ResidentRuntime>).findingsScheduler;
+      if (findings) {
+        logger.log(
+          `findings pass: every ${findings.state.cadence} into "${findings.state.collection}" (report-only)`
+        );
+      }
     }
 
     if (!options.noSyncOnStart) {

package/src/cli/commands/doctor.ts

@@ -21,6 +21,11 @@ import {
   loadConfig,
 } from "../../config";
 import { isConnectorActivationComplete } from "../../core/activation-connector-health";
+import {
+  findingsRunStatePathForIndex,
+  readFindingsRunStatus,
+  resolveFindingsSchedule,
+} from "../../core/findings-run-state";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
@@ -560,6 +565,69 @@ async function checkSqliteExtensions(): Promise<DoctorCheck[]> {
   return checks;
 }
 
+/**
+ * Report the daemon's scheduled findings pass from its persisted state so a
+ * misconfigured, starved, or failing scheduler is visible without the daemon.
+ */
+export async function checkFindingsPass(
+  config: Config,
+  indexName?: string
+): Promise<DoctorCheck> {
+  const name = "findings-pass";
+  const resolution = resolveFindingsSchedule(config);
+  if (!resolution.ok) {
+    return {
+      name,
+      status: "error",
+      message: "misconfigured",
+      details: [resolution.error],
+    };
+  }
+  if (!resolution.enabled) {
+    return {
+      name,
+      status: "ok",
+      message: "disabled (opt-in via findings.enabled)",
+    };
+  }
+  const status = await readFindingsRunStatus(
+    findingsRunStatePathForIndex(indexName)
+  );
+  const schedule = `every ${resolution.schedule.cadence} into "${resolution.schedule.collection.name}"`;
+  if (!status) {
+    return {
+      name,
+      status: "warn",
+      message: `enabled (${schedule}) but no run state recorded`,
+      details: ["Start gno daemon; the pass only runs inside the daemon."],
+    };
+  }
+  const details = [
+    `last run: ${status.lastRunAt ?? "never"}`,
+    `last success: ${status.lastSuccessAt ?? "never"}`,
+    `next due: ${status.nextDueAt}`,
+  ];
+  if (status.counts) {
+    details.push(
+      `counts: ${status.counts.open} open, ${status.counts.written} new, ${status.counts.resolved} resolved`
+    );
+  }
+  if (status.error) details.push(`error: ${status.error}`);
+  const statusOf: Record<typeof status.state, DoctorCheckStatus> = {
+    pending: "ok",
+    success: "ok",
+    skipped_lease: "warn",
+    overdue: "warn",
+    failed: "error",
+  };
+  return {
+    name,
+    status: statusOf[status.state],
+    message: `${status.state} (${schedule})`,
+    details,
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Implementation
 // ─────────────────────────────────────────────────────────────────────────────
@@ -603,6 +671,9 @@ export async function doctor(
   // Embedding fingerprint freshness
   checks.push(await checkEmbeddingFingerprints(config, options.indexName));
 
+  // Scheduled findings pass (daemon-only, opt-in)
+  checks.push(await checkFindingsPass(config, options.indexName));
+
   const activation = await buildDoctorActivation(config, options);
   checks.push(checkRetrievalActivation(activation));
   const connectorActivation = checkConnectorActivation(activation);