@gmickel/gno 0.28.2 → 0.29.0

package/src/serve/connectors.ts

@@ -0,0 +1,243 @@
+import type { McpScope, McpTarget } from "../cli/commands/mcp/paths";
+import type { SkillScope, SkillTarget } from "../cli/commands/skill/paths";
+
+import { installMcpToTarget } from "../cli/commands/mcp/install";
+import {
+  buildMcpServerEntry,
+  getTargetDisplayName,
+} from "../cli/commands/mcp/paths";
+import { checkMcpTargetStatus } from "../cli/commands/mcp/status";
+import { installSkillToTarget } from "../cli/commands/skill/install";
+import { resolveSkillPaths } from "../cli/commands/skill/paths";
+
+export interface ConnectorStatus {
+  id: string;
+  appName: string;
+  installKind: "skill" | "mcp";
+  target: string;
+  scope: "user" | "project";
+  installed: boolean;
+  path: string;
+  summary: string;
+  nextAction: string;
+  mode: {
+    label: string;
+    detail: string;
+  };
+  error?: string;
+}
+
+interface SkillConnectorDefinition {
+  id: string;
+  appName: string;
+  installKind: "skill";
+  target: SkillTarget;
+  scope: SkillScope;
+  mode: ConnectorStatus["mode"];
+}
+
+interface McpConnectorDefinition {
+  id: string;
+  appName: string;
+  installKind: "mcp";
+  target: McpTarget;
+  scope: McpScope;
+  mode: ConnectorStatus["mode"];
+}
+
+type ConnectorDefinition = SkillConnectorDefinition | McpConnectorDefinition;
+
+const CONNECTOR_DEFINITIONS: ConnectorDefinition[] = [
+  {
+    id: "claude-code-skill",
+    appName: "Claude Code",
+    installKind: "skill",
+    target: "claude",
+    scope: "user",
+    mode: {
+      label: "Read/search via skill",
+      detail:
+        "Recommended default. The agent can search and retrieve with GNO without editing client JSON.",
+    },
+  },
+  {
+    id: "claude-desktop-mcp",
+    appName: "Claude Desktop",
+    installKind: "mcp",
+    target: "claude-desktop",
+    scope: "user",
+    mode: {
+      label: "Read/search via MCP",
+      detail:
+        "Recommended default. Write-capable MCP can stay an advanced CLI step.",
+    },
+  },
+  {
+    id: "cursor-mcp",
+    appName: "Cursor",
+    installKind: "mcp",
+    target: "cursor",
+    scope: "user",
+    mode: {
+      label: "Read/search via MCP",
+      detail: "Recommended default for editor-side agent access.",
+    },
+  },
+  {
+    id: "codex-skill",
+    appName: "Codex",
+    installKind: "skill",
+    target: "codex",
+    scope: "user",
+    mode: {
+      label: "Read/search via skill",
+      detail:
+        "Fastest setup for Codex CLI. MCP remains available separately if needed later.",
+    },
+  },
+  {
+    id: "opencode-skill",
+    appName: "OpenCode",
+    installKind: "skill",
+    target: "opencode",
+    scope: "user",
+    mode: {
+      label: "Read/search via skill",
+      detail: "Recommended default. Uses the existing skill install path.",
+    },
+  },
+  {
+    id: "openclaw-skill",
+    appName: "OpenClaw",
+    installKind: "skill",
+    target: "openclaw",
+    scope: "user",
+    mode: {
+      label: "Read/search via skill",
+      detail:
+        "Recommended default for local agent access without manual file edits.",
+    },
+  },
+] as const;
+
+export async function getConnectorStatuses(overrides?: {
+  cwd?: string;
+  homeDir?: string;
+}): Promise<ConnectorStatus[]> {
+  const statuses = await Promise.all(
+    CONNECTOR_DEFINITIONS.map(async (definition) => {
+      if (definition.installKind === "skill") {
+        const paths = resolveSkillPaths({
+          scope: definition.scope,
+          target: definition.target,
+          ...overrides,
+        });
+        const skillMdPath = `${paths.gnoDir}/SKILL.md`;
+        const installed = await Bun.file(skillMdPath).exists();
+        return {
+          id: definition.id,
+          appName: definition.appName,
+          installKind: definition.installKind,
+          target: definition.target,
+          scope: definition.scope,
+          installed,
+          path: paths.gnoDir,
+          summary: installed
+            ? `${definition.appName} skill is installed.`
+            : `${definition.appName} skill is not installed yet.`,
+          nextAction: installed
+            ? "Restart the agent to reload the skill."
+            : "Install the skill from the app.",
+          mode: definition.mode,
+        } satisfies ConnectorStatus;
+      }
+
+      const status = await checkMcpTargetStatus(
+        definition.target,
+        definition.scope,
+        overrides ?? {}
+      );
+      return {
+        id: definition.id,
+        appName: definition.appName,
+        installKind: definition.installKind,
+        target: definition.target,
+        scope: definition.scope,
+        installed: status.configured,
+        path: status.configPath,
+        summary: status.configured
+          ? `${definition.appName} MCP is configured.`
+          : `${definition.appName} MCP is not configured yet.`,
+        nextAction: status.configured
+          ? `Restart ${definition.appName} to reload the server.`
+          : "Install the MCP connector from the app.",
+        mode: definition.mode,
+        error: status.error,
+      } satisfies ConnectorStatus;
+    })
+  );
+
+  return statuses;
+}
+
+export async function installConnector(
+  id: string,
+  options?: {
+    reinstall?: boolean;
+  },
+  overrides?: { cwd?: string; homeDir?: string }
+): Promise<ConnectorStatus> {
+  const definition = CONNECTOR_DEFINITIONS.find((entry) => entry.id === id);
+  if (!definition) {
+    throw new Error(`Unknown connector: ${id}`);
+  }
+
+  const currentStatuses = await getConnectorStatuses(overrides);
+  const currentStatus = currentStatuses.find((entry) => entry.id === id);
+  if (currentStatus?.installed && !options?.reinstall) {
+    throw new Error(
+      `${currentStatus.appName} is already installed. Reinstall explicitly to overwrite the existing GNO entry.`
+    );
+  }
+
+  if (definition.installKind === "skill") {
+    await installSkillToTarget(
+      definition.scope,
+      definition.target,
+      options?.reinstall ?? false,
+      overrides
+    );
+  } else {
+    await installMcpToTarget(
+      definition.target,
+      definition.scope,
+      buildMcpServerEntry({ enableWrite: false }),
+      {
+        force: options?.reinstall ?? false,
+        dryRun: false,
+        ...overrides,
+      }
+    );
+  }
+
+  const [status] = await getConnectorStatuses(overrides).then((all) =>
+    all.filter((entry) => entry.id === id)
+  );
+  if (!status) {
+    throw new Error(`Failed to reload connector: ${id}`);
+  }
+  return status;
+}
+
+export function getConnectorDisplayName(id: string): string {
+  const definition = CONNECTOR_DEFINITIONS.find((entry) => entry.id === id);
+  if (!definition) {
+    return id;
+  }
+
+  if (definition.installKind === "mcp") {
+    return `${definition.appName} (${getTargetDisplayName(definition.target)})`;
+  }
+
+  return definition.appName;
+}

package/src/serve/context.ts

@@ -15,6 +15,9 @@ import type {
   RerankPort,
 } from "../llm/types";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
+import type { DocumentEventBus } from "./doc-events";
+import type { EmbedScheduler } from "./embed-scheduler";
+import type { CollectionWatchService } from "./watch-service";
 
 import { LlmAdapter } from "../llm/nodeLlamaCpp/adapter";
 import { resolveDownloadPolicy } from "../llm/policy";
@@ -72,6 +75,9 @@ export interface ServerContext {
     hybrid: boolean;
     answer: boolean;
   };
+  scheduler?: EmbedScheduler | null;
+  eventBus?: DocumentEventBus | null;
+  watchService?: CollectionWatchService | null;
 }
 
 /**
@@ -190,6 +196,9 @@ export async function createServerContext(
     answerPort,
     rerankPort,
     capabilities,
+    scheduler: null,
+    eventBus: null,
+    watchService: null,
   };
 }
 

package/src/serve/doc-events.ts

@@ -9,7 +9,14 @@ export interface DocumentEvent {
   changedAt: string;
 }
 
+export interface DocumentEventBusState {
+  connectedClients: number;
+  retryMs: number;
+}
+
 const encoder = new TextEncoder();
+const EVENT_RETRY_MS = 2_000;
+const KEEPALIVE_MS = 15_000;
 
 export class DocumentEventBus {
   readonly #controllers = new Set<
@@ -20,13 +27,29 @@ export class DocumentEventBus {
     const controllers = this.#controllers;
     let streamController: ReadableStreamDefaultController<Uint8Array> | null =
       null;
+    let keepaliveTimer: ReturnType<typeof setInterval> | null = null;
     const stream = new ReadableStream<Uint8Array>({
       start(controller) {
         streamController = controller;
         controllers.add(controller);
-        controller.enqueue(encoder.encode(": connected\n\n"));
+        controller.enqueue(
+          encoder.encode(`retry: ${EVENT_RETRY_MS}\n: connected\n\n`)
+        );
+        keepaliveTimer = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+          } catch {
+            if (keepaliveTimer) {
+              clearInterval(keepaliveTimer);
+            }
+            controllers.delete(controller);
+          }
+        }, KEEPALIVE_MS);
       },
       cancel() {
+        if (keepaliveTimer) {
+          clearInterval(keepaliveTimer);
+        }
         if (streamController) {
           controllers.delete(streamController);
         }
@@ -66,4 +89,11 @@ export class DocumentEventBus {
     }
     this.#controllers.clear();
   }
+
+  getState(): DocumentEventBusState {
+    return {
+      connectedClients: this.#controllers.size,
+      retryMs: EVENT_RETRY_MS,
+    };
+  }
 }

package/src/serve/embed-scheduler.ts

@@ -29,6 +29,8 @@ export interface EmbedSchedulerState {
   pendingDocCount: number;
   running: boolean;
   nextRunAt?: number;
+  lastRunAt?: number;
+  lastResult?: EmbedResult;
 }
 
 export interface EmbedResult {
@@ -79,6 +81,8 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
   let firstPendingAt: number | null = null;
   let nextRunAt: number | null = null; // Accurate timer due time
   let disposed = false;
+  let lastRunAt: number | null = null;
+  let lastResult: EmbedResult | null = null;
 
   const stats = createVectorStatsPort(db);
 
@@ -179,6 +183,8 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
     let result: EmbedResult;
     try {
       result = await runEmbed();
+      lastRunAt = Date.now();
+      lastResult = result;
     } finally {
       running = false;
     }
@@ -247,6 +253,12 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
       if (nextRunAt !== null) {
         state.nextRunAt = nextRunAt;
       }
+      if (lastRunAt !== null) {
+        state.lastRunAt = lastRunAt;
+      }
+      if (lastResult) {
+        state.lastResult = lastResult;
+      }
 
       return state;
     },

package/src/serve/import-preview.ts

@@ -0,0 +1,173 @@
+// node:fs/promises readdir: no Bun recursive directory API with this shape
+import { readdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+
+import type { Config } from "../config/types";
+
+export interface ImportPreview {
+  path: string;
+  suggestedName: string;
+  folderType: "obsidian-vault" | "notes-folder" | "mixed-docs" | "binary-heavy";
+  counts: {
+    markdown: number;
+    text: number;
+    pdf: number;
+    office: number;
+    other: number;
+    folders: number;
+    scannedFiles: number;
+    truncated: boolean;
+  };
+  signals: string[];
+  guidance: string[];
+  conflicts: string[];
+}
+
+const PREVIEW_FILE_LIMIT = 400;
+
+function extname(path: string): string {
+  const idx = path.lastIndexOf(".");
+  return idx >= 0 ? path.slice(idx).toLowerCase() : "";
+}
+
+export async function analyzeImportPath(
+  config: Config,
+  path: string,
+  name?: string
+): Promise<ImportPreview> {
+  const suggestedName = (name || basename(path)).toLowerCase();
+  const counts = {
+    markdown: 0,
+    text: 0,
+    pdf: 0,
+    office: 0,
+    other: 0,
+    folders: 0,
+    scannedFiles: 0,
+    truncated: false,
+  };
+  const signals = new Set<string>();
+  const guidance: string[] = [];
+  const conflicts: string[] = [];
+  const queue = [path];
+
+  if (
+    config.collections.some((collection) => collection.name === suggestedName)
+  ) {
+    conflicts.push(`Collection name "${suggestedName}" already exists.`);
+  }
+  const samePath = config.collections.find(
+    (collection) => collection.path === path
+  );
+  if (samePath) {
+    conflicts.push(`This folder is already indexed as "${samePath.name}".`);
+  }
+
+  while (queue.length > 0 && counts.scannedFiles < PREVIEW_FILE_LIMIT) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const entryName = String(entry.name);
+      if (counts.scannedFiles >= PREVIEW_FILE_LIMIT) {
+        counts.truncated = true;
+        break;
+      }
+
+      if (entry.isDirectory()) {
+        counts.folders += 1;
+        if (entryName === ".obsidian") {
+          signals.add("Obsidian config detected");
+        }
+        if (entryName === ".git") {
+          signals.add("Git repo detected");
+        }
+        if (!entryName.startsWith(".")) {
+          queue.push(join(current, entryName));
+        }
+        continue;
+      }
+
+      counts.scannedFiles += 1;
+      const ext = extname(entryName);
+      if (ext === ".md") {
+        counts.markdown += 1;
+        continue;
+      }
+      if (ext === ".txt") {
+        counts.text += 1;
+        continue;
+      }
+      if (ext === ".pdf") {
+        counts.pdf += 1;
+        continue;
+      }
+      if ([".docx", ".pptx", ".xlsx"].includes(ext)) {
+        counts.office += 1;
+        continue;
+      }
+      counts.other += 1;
+    }
+  }
+
+  const noteLikeCount = counts.markdown + counts.text;
+  const binaryCount = counts.pdf + counts.office;
+
+  let folderType: ImportPreview["folderType"] = "mixed-docs";
+  if (signals.has("Obsidian config detected")) {
+    folderType = "obsidian-vault";
+  } else if (
+    noteLikeCount > 0 &&
+    binaryCount === 0 &&
+    counts.other < noteLikeCount
+  ) {
+    folderType = "notes-folder";
+  } else if (binaryCount > noteLikeCount) {
+    folderType = "binary-heavy";
+  }
+
+  if (folderType === "obsidian-vault") {
+    guidance.push(
+      "GNO will index your vault files and wiki links, but it does not replace the Obsidian plugin ecosystem."
+    );
+  }
+  if (binaryCount > 0) {
+    guidance.push(
+      "PDF, DOCX, PPTX, and XLSX files are imported as searchable read-only source material."
+    );
+  }
+  if (counts.other > noteLikeCount && counts.other > 10) {
+    guidance.push(
+      "This folder has a lot of unsupported or non-document files. Consider narrowing the pattern or excludes before indexing."
+    );
+  }
+  if (counts.truncated) {
+    guidance.push(
+      "Preview is sampled from the first few hundred files, not a full recursive inventory."
+    );
+  }
+  if (guidance.length === 0) {
+    guidance.push(
+      "This folder looks straightforward to import with the current defaults."
+    );
+  }
+
+  return {
+    path,
+    suggestedName,
+    folderType,
+    counts,
+    signals: [...signals],
+    guidance,
+    conflicts,
+  };
+}