@schlenkr/ragents 0.1.0

package/plugins/ragents.documents/web/index.tsx

@@ -0,0 +1,279 @@
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import type { ToolInfo } from "@aicontainer/web/chat/types";
+import {
+  DocumentPanel,
+  DocumentToolCall,
+  documentMessagesFrom,
+  documentsFrom as documentsFromMessages,
+  formatFromName,
+  formatOf,
+  type RunDocument as Document,
+  type DocumentSection,
+} from "./DocumentViewer";
+import { fetchRunFiles, runFileContentUrl } from "./api";
+import type { RunFileEntry, RunFilesListing } from "../contract";
+import { runArtifactContentUrl, runViewFrom, type RunView } from "@aicontainer/plugins/ragents.orchestration/web/contract";
+import { Alert, Badge } from "@aicontainer/web/ui";
+import {
+  pluginRoutePrefixFrom,
+  type SessionContext,
+  type SessionProviderProps,
+  type ToolPresenterContext,
+  type WebPlugin,
+  type WebPluginDescriptor,
+  type WorkspaceTabContext,
+} from "@aicontainer/web/PluginRegistry";
+
+export const DOCUMENTS_PLUGIN_ID = "ragents.documents";
+export const DOCUMENTS_TAB_ID = "ragents.documents.library";
+
+const pathArgumentsFrom = (tool: ToolInfo): { title: string; path: string; format?: string } | undefined => {
+  if (tool.name !== "show_document") return undefined;
+  try {
+    const args = JSON.parse(tool.arguments) as { title?: unknown; path?: unknown; content?: unknown; format?: unknown };
+    if (typeof args.title !== "string" || typeof args.path !== "string" || typeof args.content === "string") return undefined;
+    return { title: args.title, path: args.path, ...(typeof args.format === "string" ? { format: args.format } : {}) };
+  } catch {
+    return undefined;
+  }
+};
+
+const pathDocumentFrom = (tool: ToolInfo, routePrefix: string, runId: string): Document | undefined => {
+  const args = pathArgumentsFrom(tool);
+  if (!args) return undefined;
+  const format = args.format === "markdown" || args.format === "text" || args.format === "html"
+    ? args.format
+    : formatFromName(args.path);
+  return { id: tool.id, title: args.title, format, contentUrl: runFileContentUrl(routePrefix, runId, args.path) };
+};
+
+const chatDocumentFrom = (tool: ToolInfo, routePrefix: string, runId: string): Document | undefined =>
+  documentsFromMessages([{
+    key: tool.id,
+    role: "tool",
+    text: tool.name,
+    tool,
+  }])[0] ?? pathDocumentFrom(tool, routePrefix, runId);
+
+const pathDocumentsFromMessages = (
+  messages: SessionContext["messages"],
+  routePrefix: string,
+  runId: string,
+): Document[] =>
+  messages.flatMap((message) => {
+    const tool = message.tool;
+    if (!tool) return [];
+    const document = pathDocumentFrom(tool, routePrefix, runId);
+    return document ? [document] : [];
+  });
+
+interface RunFilesState {
+  listing: RunFilesListing | undefined;
+  error: string | undefined;
+}
+
+const RunFilesContext = createContext<RunFilesState | undefined>(undefined);
+
+const useRunFilesContext = (): RunFilesState => {
+  const state = useContext(RunFilesContext);
+  if (!state) throw new Error("Dokumente-Plugin ist nicht aktiv");
+  return state;
+};
+
+const useRunFiles = (session: SessionContext): RunFilesState => {
+  const [listing, setListing] = useState<RunFilesListing>();
+  const [error, setError] = useState<string>();
+  const runId = session.session.id;
+
+  useEffect(() => {
+    let alive = true;
+    const load = () => void fetchRunFiles(runId)
+      .then((value) => {
+        if (!alive) return;
+        setListing(value);
+        setError(undefined);
+      })
+      .catch((cause: unknown) => alive && setError(cause instanceof Error ? cause.message : String(cause)));
+    load();
+    if (!session.running) {
+      return () => {
+        alive = false;
+      };
+    }
+    const timer = setInterval(load, 5000);
+    return () => {
+      alive = false;
+      clearInterval(timer);
+    };
+  }, [runId, session.running]);
+
+  return useMemo(() => ({ listing, error }), [listing, error]);
+};
+
+function DocumentsSessionProvider({ children, session }: SessionProviderProps) {
+  const state = useRunFiles(session);
+  return <RunFilesContext.Provider value={state}>{children}</RunFilesContext.Provider>;
+}
+
+const resultSection = (runId: string, view: RunView): DocumentSection => {
+  const handles = new Map(view.actors.map((actor) => [actor.id, actor.handle]));
+  return {
+    id: "ergebnisse",
+    label: "Ergebnisse",
+    kind: "ergebnisse",
+    documents: view.artifacts.map((artifact) => {
+      const handle = handles.get(artifact.createdBy);
+      return {
+        id: artifact.id,
+        title: artifact.title,
+        format: formatOf(artifact.mediaType),
+        contentUrl: runArtifactContentUrl(runId, artifact.id),
+        createdAt: artifact.createdAt,
+        size: artifact.size,
+        ...(handle ? { meta: `@${handle}` } : {}),
+      };
+    }),
+  };
+};
+
+const sectionsFrom = (
+  routePrefix: string,
+  session: SessionContext,
+  listing: RunFilesListing | undefined,
+): { sections: DocumentSection[]; truncated: boolean } => {
+  const runId = session.session.id;
+  const view = runViewFrom(session.runView);
+  const fileDocument = (directory: string | undefined, entry: RunFileEntry): Document => {
+    const relative = directory ? `${directory}/${entry.path}` : entry.path;
+    return {
+      id: `file:${relative}`,
+      title: entry.path,
+      format: formatFromName(entry.path),
+      contentUrl: `${runFileContentUrl(routePrefix, runId, relative)}&v=${encodeURIComponent(entry.modifiedAt)}`,
+      createdAt: entry.modifiedAt,
+      size: entry.size,
+    };
+  };
+
+  const sections: DocumentSection[] = [
+    ...(listing?.groups ?? []).map((group) => ({
+      id: `ablage/${group.directory}`,
+      label: group.directory,
+      kind: "ablage" as const,
+      documents: group.files.map((entry) => fileDocument(group.directory, entry)),
+    })),
+    ...(listing && listing.loose.length > 0
+      ? [{
+          id: "ablage",
+          label: "Ablage",
+          kind: "ablage" as const,
+          documents: listing.loose.map((entry) => fileDocument(undefined, entry)),
+        }]
+      : []),
+    ...(view && view.artifacts.length > 0 ? [resultSection(runId, view)] : []),
+  ];
+  const documentMessages = documentMessagesFrom(session.messages, session.actorConversations);
+  const chat = [
+    ...documentsFromMessages(documentMessages),
+    ...pathDocumentsFromMessages(documentMessages, routePrefix, session.session.id),
+  ];
+  if (chat.length > 0) sections.push({ id: "chat", label: "Im Chat gezeigt", kind: "chat", documents: chat });
+  return { sections, truncated: listing?.truncated ?? false };
+};
+
+const contribution = (routePrefix: string) => {
+  function DocumentsPanelContribution({ navigation, selection, session }: WorkspaceTabContext) {
+    const { listing, error } = useRunFilesContext();
+    const { sections, truncated } = useMemo(
+      () => sectionsFrom(routePrefix, session, listing),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- session is rebuilt per render; only these parts matter
+      [session.messages, session.actorConversations, session.runView, session.session.id, listing],
+    );
+    return (
+      <>
+        {error && (
+          <Alert className="shrink-0 rounded-none border-x-0 border-t-0 border-b-border-soft bg-destructive/8 px-2.5 py-2 text-[0.68rem]" variant="destructive">
+            {error}
+          </Alert>
+        )}
+        <DocumentPanel
+          activeId={typeof selection === "string" ? selection : undefined}
+          sections={sections}
+          truncated={truncated}
+          onSelect={(id) => navigation.openTab(DOCUMENTS_TAB_ID, id ?? null)}
+        />
+      </>
+    );
+  }
+
+  function DocumentsBadge({ session }: WorkspaceTabContext) {
+    const { listing } = useRunFilesContext();
+    const { sections } = useMemo(
+      () => sectionsFrom(routePrefix, session, listing),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- session is rebuilt per render; only these parts matter
+      [session.messages, session.actorConversations, session.runView, session.session.id, listing],
+    );
+    const count = sections.reduce((sum, section) => sum + section.documents.length, 0);
+    return count > 0 ? <Badge className="tabular-nums" variant="secondary">{count}</Badge> : null;
+  }
+
+  return { DocumentsPanelContribution, DocumentsBadge };
+};
+
+function DocumentInline({ navigation, session, tool, routePrefix }: ToolPresenterContext & { routePrefix: string }) {
+  const document = chatDocumentFrom(tool, routePrefix, session.session.id);
+  if (!document) return null;
+  const status = tool.isError ? "error" : tool.result === undefined ? "running" : "ready";
+  return (
+    <DocumentToolCall
+      active={navigation.activeTabId === DOCUMENTS_TAB_ID && navigation.selectionFor(DOCUMENTS_TAB_ID) === document.id}
+      document={document}
+      onOpen={() => navigation.openTab(DOCUMENTS_TAB_ID, document.id)}
+      status={status}
+    />
+  );
+}
+
+function IconDocument() {
+  return (
+    <svg aria-hidden fill="none" height="15" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.7" viewBox="0 0 24 24" width="15">
+      <path d="M6 3h8l4 4v14H6zM14 3v5h4M9 13h6M9 17h4" />
+    </svg>
+  );
+}
+
+const configuredPlugin = (descriptor: WebPluginDescriptor, routePrefix: string): WebPlugin => {
+  const { DocumentsPanelContribution, DocumentsBadge } = contribution(routePrefix);
+  return {
+    ...descriptor,
+    needsRunView: true,
+    SessionProvider: DocumentsSessionProvider,
+    workspaceTabs: [{
+      id: DOCUMENTS_TAB_ID,
+      label: "Dokumente",
+      order: 200,
+      Icon: IconDocument,
+      Panel: DocumentsPanelContribution,
+      Badge: DocumentsBadge,
+    }],
+    toolPresenters: [{
+      toolName: "show_document",
+      Inline: (props) => <DocumentInline {...props} routePrefix={routePrefix} />,
+      reveal: (tool, session) => chatDocumentFrom(tool, routePrefix, session.session.id)
+        ? { tabId: DOCUMENTS_TAB_ID, selection: tool.id }
+        : undefined,
+    }],
+    entityPresenters: [{
+      reveal: (entity) => entity.type === "artifact"
+        ? { tabId: DOCUMENTS_TAB_ID, selection: entity.id }
+        : undefined,
+    }],
+  };
+};
+
+const descriptor: WebPluginDescriptor = { id: DOCUMENTS_PLUGIN_ID };
+
+export const webPlugin: WebPlugin = {
+  ...descriptor,
+  activate: (config) => configuredPlugin(descriptor, pluginRoutePrefixFrom(descriptor.id, config)),
+};

package/plugins/ragents.lsp-fsharp/provision.ts

@@ -0,0 +1,74 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { FSHARP_SERVER_FILE } from "@aicontainer/workspace-executor";
+import {
+  DOTNET_INSTRUCTION,
+  downloadArchive,
+  dotnetRuntimeMajors,
+  provisionGap,
+  provisionReady,
+  readProvisionStamp,
+  readZipNames,
+  unpackArchive,
+  writeProvisionStamp,
+  type ArchiveDownload,
+  type PluginProvision,
+  type ProvisionState,
+} from "@aicontainer/server/plugin-support/provision.js";
+
+export const FSAUTOCOMPLETE_VERSION = "0.83.0";
+
+const FEED = "https://api.nuget.org/v3/flatcontainer";
+const PACKAGE = "fsautocomplete";
+const TOOL_FOLDER = /^tools\/net(\d+)\.0\/any\//;
+
+export const fsautocompleteArchiveUrl = `${FEED}/${PACKAGE}/${FSAUTOCOMPLETE_VERSION}/${PACKAGE}.${FSAUTOCOMPLETE_VERSION}.nupkg`;
+
+/** Das Werkzeugpaket bringt je Zielplattform einen Ordner mit; genommen wird die höchste Laufzeit, die es hier gibt. */
+const toolPrefix = (names: readonly string[], majors: readonly number[]): string => {
+  const offered = names
+    .map((name) => TOOL_FOLDER.exec(name))
+    .filter((match): match is RegExpExecArray => match !== null)
+    .map((match) => ({ prefix: match[0], major: Number(match[1]) }));
+  const usable = offered.filter((entry) => majors.includes(entry.major)).sort((left, right) => right.major - left.major);
+  const chosen = usable[0];
+  if (!chosen) {
+    throw new Error(`${PACKAGE} ${FSAUTOCOMPLETE_VERSION} bringt nur ${[...new Set(offered.map((entry) => `net${entry.major}.0`))].join(", ")} mit; `
+      + `installiert sind die .NET-Laufzeiten ${majors.join(", ")}`);
+  }
+  return chosen.prefix;
+};
+
+export const createFsharpProvision = (
+  download: ArchiveDownload = downloadArchive,
+  runtimes: () => Promise<readonly number[] | undefined> = dotnetRuntimeMajors,
+): PluginProvision => {
+  const serverFile = (target: string): string => path.join(target, ...FSHARP_SERVER_FILE.split("/"));
+  const check = async (target: string): Promise<ProvisionState> => {
+    if (await runtimes() === undefined) return provisionGap("dotnet", DOTNET_INSTRUCTION, false);
+    const installed = await stat(serverFile(target)).catch(() => undefined);
+    if (installed?.isFile() && await readProvisionStamp(target) === FSAUTOCOMPLETE_VERSION) return provisionReady;
+    return provisionGap("fsautocomplete", `fsautocomplete ${FSAUTOCOMPLETE_VERSION} fehlt unter ${serverFile(target)}`, true);
+  };
+  return {
+    check,
+    apply: async (target, log) => {
+      const state = await check(target);
+      if (state.kind === "ready") return;
+      if (!state.installable) throw new Error(state.instruction);
+      const majors = await runtimes();
+      if (!majors) throw new Error(DOTNET_INSTRUCTION);
+      log(`fsautocomplete ${FSAUTOCOMPLETE_VERSION} laden`);
+      const archive = await download(fsautocompleteArchiveUrl);
+      const prefix = toolPrefix(readZipNames(archive), majors);
+      const files = await unpackArchive(archive, prefix, target, "fsautocomplete");
+      if (!(await stat(serverFile(target)).catch(() => undefined))?.isFile()) {
+        throw new Error(`Das Paket ${PACKAGE} ${FSAUTOCOMPLETE_VERSION} enthält ${prefix}fsautocomplete.dll nicht`);
+      }
+      await writeProvisionStamp(target, FSAUTOCOMPLETE_VERSION);
+      log(`${files} Dateien aus ${prefix} nach ${path.join(target, "fsautocomplete")}`);
+    },
+  };
+};
+
+export const provision = createFsharpProvision();

package/plugins/ragents.lsp-fsharp/server/index.ts

@@ -0,0 +1,16 @@
+import { fsharpAdapter, FSHARP_SERVER_VARIABLE } from "@aicontainer/workspace-executor";
+import { createLanguageServerPlugin } from "@aicontainer/server/plugin-support/language-server/plugin.js";
+import type { PluginModule } from "@aicontainer/server/plugin-support/plugin-module.js";
+
+export const fsharpConfigDescriptors = [
+  { key: FSHARP_SERVER_VARIABLE, source: "environment" },
+] as const;
+
+export const plugin: PluginModule = {
+  create: () => createLanguageServerPlugin({
+    id: "ragents.lsp-fsharp",
+    adapter: fsharpAdapter,
+    tabLabel: "F#",
+    configDescriptors: fsharpConfigDescriptors,
+  }),
+};

package/plugins/ragents.lsp-fsharp/web/index.tsx

@@ -0,0 +1,7 @@
+import { languageServerWebPlugin } from "@aicontainer/plugins/ragents.lsp-roslyn/web/language-server-plugin";
+
+export const webPlugin = languageServerWebPlugin("ragents.lsp-fsharp", LanguageIcon);
+
+function LanguageIcon() {
+  return <span aria-hidden="true" className="font-mono text-[12px] font-bold">F#</span>;
+}

package/plugins/ragents.lsp-roslyn/provision.ts

@@ -0,0 +1,54 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { ROSLYN_SERVER_FILE } from "@aicontainer/workspace-executor";
+import {
+  DOTNET_INSTRUCTION,
+  downloadArchive,
+  dotnetRuntimeMajors,
+  provisionGap,
+  provisionReady,
+  readProvisionStamp,
+  unpackArchive,
+  writeProvisionStamp,
+  type ArchiveDownload,
+  type PluginProvision,
+  type ProvisionState,
+} from "@aicontainer/server/plugin-support/provision.js";
+
+export const ROSLYN_VERSION = "5.4.0-2.26179.14";
+
+const FEED = "https://pkgs.dev.azure.com/azure-public/vside/_packaging/vs-impl/nuget/v3/flat2";
+const PACKAGE = "microsoft.codeanalysis.languageserver.neutral";
+const PREFIX = "content/LanguageServer/neutral/";
+
+export const roslynArchiveUrl = `${FEED}/${PACKAGE}/${ROSLYN_VERSION}/${PACKAGE}.${ROSLYN_VERSION}.nupkg`;
+
+export const createRoslynProvision = (
+  download: ArchiveDownload = downloadArchive,
+  runtimes: () => Promise<readonly number[] | undefined> = dotnetRuntimeMajors,
+): PluginProvision => {
+  const serverFile = (target: string): string => path.join(target, ...ROSLYN_SERVER_FILE.split("/"));
+  const check = async (target: string): Promise<ProvisionState> => {
+    if (await runtimes() === undefined) return provisionGap("dotnet", DOTNET_INSTRUCTION, false);
+    const installed = await stat(serverFile(target)).catch(() => undefined);
+    if (installed?.isFile() && await readProvisionStamp(target) === ROSLYN_VERSION) return provisionReady;
+    return provisionGap("roslyn", `Microsoft.CodeAnalysis.LanguageServer ${ROSLYN_VERSION} fehlt unter ${serverFile(target)}`, true);
+  };
+  return {
+    check,
+    apply: async (target, log) => {
+      const state = await check(target);
+      if (state.kind === "ready") return;
+      if (!state.installable) throw new Error(state.instruction);
+      log(`Roslyn ${ROSLYN_VERSION} laden`);
+      const files = await unpackArchive(await download(roslynArchiveUrl), PREFIX, target, "roslyn");
+      if (!(await stat(serverFile(target)).catch(() => undefined))?.isFile()) {
+        throw new Error(`Das Paket ${PACKAGE} ${ROSLYN_VERSION} enthält ${ROSLYN_SERVER_FILE} nicht`);
+      }
+      await writeProvisionStamp(target, ROSLYN_VERSION);
+      log(`${files} Dateien nach ${path.join(target, "roslyn")}`);
+    },
+  };
+};
+
+export const provision = createRoslynProvision();

package/plugins/ragents.lsp-roslyn/server/index.ts

@@ -0,0 +1,15 @@
+import { roslynAdapter, ROSLYN_SERVER_VARIABLE } from "@aicontainer/workspace-executor";
+import { createLanguageServerPlugin } from "@aicontainer/server/plugin-support/language-server/plugin.js";
+import type { PluginModule } from "@aicontainer/server/plugin-support/plugin-module.js";
+
+export const roslynConfigDescriptors = [
+  { key: ROSLYN_SERVER_VARIABLE, source: "environment" },
+] as const;
+
+export const plugin: PluginModule = {
+  create: () => createLanguageServerPlugin({
+    id: "ragents.lsp-roslyn",
+    adapter: roslynAdapter,
+    configDescriptors: roslynConfigDescriptors,
+  }),
+};

package/plugins/ragents.lsp-roslyn/web/api.ts

@@ -0,0 +1,10 @@
+import {
+  languageServerSnapshotContract,
+  type LanguageServerSnapshot,
+} from "@aicontainer/server/plugin-support/language-server/contract";
+import { rpc } from "@aicontainer/web/rpc";
+
+export const fetchLanguageServerSnapshot = (
+  pluginId: string,
+  runId: string,
+): Promise<LanguageServerSnapshot> => rpc.call(languageServerSnapshotContract(pluginId), { runId });

package/plugins/ragents.lsp-roslyn/web/index.tsx

@@ -0,0 +1,7 @@
+import { languageServerWebPlugin } from "./language-server-plugin";
+
+export const webPlugin = languageServerWebPlugin("ragents.lsp-roslyn", LanguageIcon);
+
+function LanguageIcon() {
+  return <span aria-hidden="true" className="font-mono text-[12px] font-bold">C#</span>;
+}