open-research 1.1.1 → 1.2.0

package/dist/chunk-W3MWVV2O.js

@@ -0,0 +1,533 @@
+import {
+  TurnManager,
+  applyProposedUpdate,
+  classifyUpdateRisk,
+  clearMemories,
+  createProviderFromStoredAuth,
+  deleteMemory,
+  getAuthStatus,
+  importCodexAuth,
+  initWorkspace,
+  listAvailableSkills,
+  loadAllMemories,
+  loginWithBrowser,
+  runAgentTurn,
+  scanWorkspace
+} from "./chunk-32Q63SUH.js";
+import {
+  appendSessionEvent,
+  listSessions,
+  loadSessionHistory
+} from "./chunk-KOBMIIQM.js";
+import {
+  clearStoredAuth
+} from "./chunk-3GZIDCV2.js";
+import {
+  ensureOpenResearchConfig,
+  saveOpenResearchConfig
+} from "./chunk-CRSHN3PQ.js";
+import {
+  getAvailableModels
+} from "./chunk-GVEVKDGV.js";
+
+// src/server/index.ts
+import { Hono as Hono12 } from "hono";
+
+// src/server/session-store.ts
+import { randomUUID } from "crypto";
+
+// src/server/bus.ts
+import { EventEmitter } from "events";
+var SessionBus = class {
+  emitter = new EventEmitter();
+  constructor() {
+    this.emitter.setMaxListeners(50);
+  }
+  emit(event) {
+    this.emitter.emit("event", event);
+  }
+  subscribe(cb) {
+    this.emitter.on("event", cb);
+    return () => {
+      this.emitter.off("event", cb);
+    };
+  }
+  /** Number of active subscribers */
+  listenerCount() {
+    return this.emitter.listenerCount("event");
+  }
+  /** Remove all subscribers */
+  removeAllListeners() {
+    this.emitter.removeAllListeners("event");
+  }
+};
+
+// src/server/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/server/session-store.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(workspaceDir) {
+    const session = {
+      id: randomUUID(),
+      workspaceDir,
+      bus: new SessionBus(),
+      history: [],
+      activeSkills: [],
+      tokenUsage: null,
+      pendingUpdates: [],
+      pendingQuestions: /* @__PURE__ */ new Map(),
+      abortController: null,
+      turnSnapshots: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  delete(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.bus.removeAllListeners();
+      session.abortController?.abort();
+      for (const deferred of session.pendingQuestions.values()) {
+        deferred.reject(new Error("Session deleted"));
+      }
+    }
+    return this.sessions.delete(id);
+  }
+  list() {
+    return Array.from(this.sessions.values());
+  }
+  /** Create a QuestionBridge for a session that uses Deferred + bus */
+  createQuestionBridge(session) {
+    return {
+      async createQuestion(question) {
+        const deferred = createDeferred();
+        session.pendingQuestions.set(question.id, deferred);
+        session.bus.emit({ type: "ask_user", question });
+        try {
+          const answer = await deferred.promise;
+          return answer;
+        } finally {
+          session.pendingQuestions.delete(question.id);
+          session.bus.emit({ type: "question_resolved", questionId: question.id });
+        }
+      }
+    };
+  }
+  /** Create an EventSink that forwards to the session bus */
+  createEventSink(session) {
+    return (event) => {
+      session.bus.emit(event);
+    };
+  }
+};
+
+// src/server/routes/sessions.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+function createSessionRoutes(sessionManager, options) {
+  const app = new Hono();
+  app.post("/", async (c) => {
+    const { workspaceDir } = await c.req.json();
+    const session = sessionManager.create(workspaceDir);
+    return c.json({ id: session.id });
+  });
+  app.get("/", async (c) => {
+    const workspaceDir = c.req.query("workspaceDir");
+    if (!workspaceDir) return c.json([]);
+    const sessions = await listSessions(workspaceDir);
+    return c.json(sessions);
+  });
+  app.get("/:id/history", async (c) => {
+    const sessionId = c.req.param("id");
+    const session = sessionManager.get(sessionId);
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const restored = await loadSessionHistory(session.workspaceDir, sessionId);
+    return c.json(restored);
+  });
+  app.delete("/:id", (c) => {
+    const sessionId = c.req.param("id");
+    sessionManager.delete(sessionId);
+    return c.json({ ok: true });
+  });
+  app.post("/:id/message", async (c) => {
+    const sessionId = c.req.param("id");
+    const session = sessionManager.get(sessionId);
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const body = await c.req.json();
+    const controller = new AbortController();
+    session.abortController = controller;
+    return streamSSE(c, async (stream) => {
+      const sink = (event) => {
+        void stream.writeSSE({ data: JSON.stringify(event) });
+      };
+      const questionBridge = sessionManager.createQuestionBridge(session);
+      const eventSink = sessionManager.createEventSink(session);
+      try {
+        const provider = await createProviderFromStoredAuth({ homeDir: options?.homeDir });
+        const workspace = await scanWorkspace(session.workspaceDir);
+        const workspaceContext = {
+          workspaceDir: session.workspaceDir,
+          runId: sessionId,
+          workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
+          availableKeys: workspace.files.map((f) => f.key),
+          fileLabels: Object.fromEntries(workspace.files.map((f) => [f.key, f.label]))
+        };
+        const result = await runAgentTurn({
+          provider,
+          message: body.message,
+          history: session.history,
+          workspace: workspaceContext,
+          homeDir: options?.homeDir,
+          model: body.model,
+          reasoningEffort: body.reasoningEffort,
+          activeSkills: session.activeSkills,
+          signal: controller.signal,
+          questionBridge,
+          eventSink: (event) => {
+            sink(event);
+            eventSink(event);
+          },
+          onTextDelta: (chunk) => sink({ type: "text_delta", content: chunk }),
+          onToolActivity: (activity) => sink({ type: "tool_activity", activity }),
+          onSubAgentProgress: (progress) => sink({ type: "subagent_progress", progress }),
+          onCompaction: () => sink({ type: "context_compacted", scope: "history", estimatedTokensBefore: 0, estimatedTokensAfter: 0 }),
+          onTokenUpdate: (usage) => sink({ type: "token_update", usage }),
+          onMemoryExtracted: (memories) => sink({ type: "memory_extracted", memories })
+        });
+        session.history.push(
+          { role: "user", content: body.message },
+          { role: "assistant", content: result.text }
+        );
+        session.activeSkills = result.activeSkills;
+        session.tokenUsage = result.tokenUsage;
+        for (const update of result.proposedUpdates) {
+          const policy = classifyUpdateRisk(update);
+          if (body.agentMode === "auto-approve" || policy.policy === "auto-apply") {
+            await applyProposedUpdate(session.workspaceDir, update);
+          } else {
+            session.pendingUpdates.push(update);
+            sink({ type: "proposed_update", update });
+          }
+        }
+        await appendSessionEvent(session.workspaceDir, sessionId, {
+          type: "chat.turn",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: {
+            prompt: body.message,
+            response: result.text,
+            proposedUpdates: result.proposedUpdates.map((u) => ({ key: u.key, summary: u.summary }))
+          }
+        });
+        sink({ type: "done", usage: result.tokenUsage });
+      } catch (error) {
+        sink({ type: "error", message: error instanceof Error ? error.message : String(error) });
+      } finally {
+        session.abortController = null;
+        await stream.writeSSE({ data: "[DONE]" });
+      }
+    });
+  });
+  app.post("/:id/abort", (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    session.abortController?.abort();
+    return c.json({ ok: true });
+  });
+  app.post("/:id/compact", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const { manualCompact } = await import("./context-manager-2FA5ANQN.js");
+    const provider = await createProviderFromStoredAuth({ homeDir: options?.homeDir });
+    const compacted = await manualCompact(session.history, provider, { homeDir: options?.homeDir });
+    session.history = compacted.messages;
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// src/server/routes/events.ts
+import { Hono as Hono2 } from "hono";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+function createEventRoutes(sessionManager) {
+  const app = new Hono2();
+  app.get("/:id", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    return streamSSE2(c, async (stream) => {
+      const unsubscribe = session.bus.subscribe((event) => {
+        void stream.writeSSE({ data: JSON.stringify(event) });
+      });
+      const heartbeat = setInterval(() => {
+        void stream.writeSSE({ data: '{"type":"heartbeat"}' });
+      }, 1e4);
+      stream.onAbort(() => {
+        clearInterval(heartbeat);
+        unsubscribe();
+      });
+      await new Promise(() => {
+      });
+    });
+  });
+  return app;
+}
+
+// src/server/routes/questions.ts
+import { Hono as Hono3 } from "hono";
+function createQuestionRoutes(sessionManager) {
+  const app = new Hono3();
+  app.post("/:id/:qid", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const questionId = c.req.param("qid");
+    const deferred = session.pendingQuestions.get(questionId);
+    if (!deferred) return c.json({ error: "No pending question with that ID" }, 404);
+    const body = await c.req.json();
+    deferred.resolve({ questionId, answer: body.answer, isCustom: body.isCustom });
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// src/server/routes/updates.ts
+import { Hono as Hono4 } from "hono";
+function createUpdateRoutes(sessionManager) {
+  const app = new Hono4();
+  app.get("/:id", (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    return c.json(session.pendingUpdates);
+  });
+  app.post("/:id/:uid/accept", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const updateId = c.req.param("uid");
+    const index = session.pendingUpdates.findIndex((u) => u.id === updateId);
+    if (index === -1) return c.json({ error: "Update not found" }, 404);
+    const update = session.pendingUpdates[index];
+    await applyProposedUpdate(session.workspaceDir, update);
+    session.pendingUpdates.splice(index, 1);
+    session.bus.emit({ type: "update_resolved", updateId, action: "accepted" });
+    return c.json({ ok: true });
+  });
+  app.post("/:id/:uid/reject", (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const updateId = c.req.param("uid");
+    const index = session.pendingUpdates.findIndex((u) => u.id === updateId);
+    if (index === -1) return c.json({ error: "Update not found" }, 404);
+    session.pendingUpdates.splice(index, 1);
+    session.bus.emit({ type: "update_resolved", updateId, action: "rejected" });
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// src/server/routes/snapshots.ts
+import { Hono as Hono5 } from "hono";
+var turnManagers = /* @__PURE__ */ new Map();
+function getTurnManager(session) {
+  let tm = turnManagers.get(session.id);
+  if (!tm) {
+    tm = new TurnManager(session.workspaceDir);
+    turnManagers.set(session.id, tm);
+    void tm.init().catch(() => {
+    });
+  }
+  return tm;
+}
+function createSnapshotRoutes(sessionManager) {
+  const app = new Hono5();
+  app.get("/:id", (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const tm = getTurnManager(session);
+    return c.json(
+      tm.getTurnSnapshots().map((s) => ({
+        turnIndex: s.turnIndex,
+        patch: s.patch,
+        timestamp: s.timestamp
+      }))
+    );
+  });
+  app.post("/:id/revert", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const { afterTurn } = await c.req.json();
+    const tm = getTurnManager(session);
+    try {
+      const result = await tm.revertToTurn(afterTurn);
+      session.bus.emit({
+        type: "snapshot_reverted",
+        revertedTurns: result.revertedTurns,
+        filesRestored: result.filesRestored
+      });
+      return c.json({ revertedTurns: result.revertedTurns, filesRestored: result.filesRestored });
+    } catch (error) {
+      return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+  });
+  app.post("/:id/unrevert", async (c) => {
+    const session = sessionManager.get(c.req.param("id"));
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    const tm = getTurnManager(session);
+    try {
+      await tm.unrevert();
+      return c.json({ ok: true });
+    } catch (error) {
+      return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+  });
+  return app;
+}
+
+// src/server/routes/workspace.ts
+import { Hono as Hono6 } from "hono";
+function createWorkspaceRoutes() {
+  const app = new Hono6();
+  app.post("/init", async (c) => {
+    const { workspaceDir } = await c.req.json();
+    await initWorkspace({ workspaceDir });
+    return c.json({ ok: true });
+  });
+  app.get("/scan", async (c) => {
+    const workspaceDir = c.req.query("workspaceDir") ?? process.cwd();
+    const result = await scanWorkspace(workspaceDir);
+    return c.json(result.files.map((f) => ({ key: f.key, label: f.label })));
+  });
+  return app;
+}
+
+// src/server/routes/auth.ts
+import { Hono as Hono7 } from "hono";
+function createAuthRoutes(options) {
+  const app = new Hono7();
+  app.get("/status", async (c) => {
+    const status = await getAuthStatus(options);
+    return c.json(status);
+  });
+  app.post("/login", async (c) => {
+    const stored = await loginWithBrowser(options);
+    return c.json({ ok: true, provider: stored.provider });
+  });
+  app.post("/login-gemini", async (c) => {
+    const { loginWithGemini } = await import("./gemini-login-EYY3EFH4.js");
+    const stored = await loginWithGemini(options);
+    return c.json({ ok: true, provider: stored.provider });
+  });
+  app.post("/import-codex", async (c) => {
+    const result = await importCodexAuth({ homeDir: options?.homeDir });
+    return c.json({ ok: true, accountId: result.accountId });
+  });
+  app.post("/logout", async (c) => {
+    await clearStoredAuth(options);
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// src/server/routes/config.ts
+import { Hono as Hono8 } from "hono";
+function createConfigRoutes(options) {
+  const app = new Hono8();
+  app.get("/", async (c) => {
+    const config = await ensureOpenResearchConfig(options);
+    return c.json(config);
+  });
+  app.put("/", async (c) => {
+    const body = await c.req.json();
+    await saveOpenResearchConfig(body, options);
+    return c.json({ ok: true });
+  });
+  app.get("/models", (c) => {
+    const models = getAvailableModels();
+    return c.json(models);
+  });
+  return app;
+}
+
+// src/server/routes/skills.ts
+import { Hono as Hono9 } from "hono";
+function createSkillRoutes(options) {
+  const app = new Hono9();
+  app.get("/", async (c) => {
+    const skills = await listAvailableSkills(options);
+    return c.json(skills);
+  });
+  return app;
+}
+
+// src/server/routes/memory.ts
+import { Hono as Hono10 } from "hono";
+function createMemoryRoutes(options) {
+  const app = new Hono10();
+  app.get("/", async (c) => {
+    const memories = await loadAllMemories(options);
+    return c.json(memories);
+  });
+  app.delete("/clear", async (c) => {
+    await clearMemories(options);
+    return c.json({ ok: true });
+  });
+  app.delete("/:id", async (c) => {
+    const id = c.req.param("id");
+    const deleted = await deleteMemory(id, options);
+    return c.json({ ok: deleted });
+  });
+  return app;
+}
+
+// src/server/routes/ontology.ts
+import { Hono as Hono11 } from "hono";
+function createOntologyRoutes() {
+  const app = new Hono11();
+  app.get("/status", async (c) => {
+    const workspaceDir = c.req.query("workspaceDir") ?? process.cwd();
+    const [{ loadOntology }, { getOntologyStatus }] = await Promise.all([
+      import("./store-LT5EGDOI.js"),
+      import("./status-GEEAGLPF.js")
+    ]);
+    const ontology = await loadOntology(workspaceDir);
+    const noteCount = ontology.notes.length;
+    const edgeCount = ontology.notes.reduce((sum, n) => sum + n.edges.length, 0);
+    const summary = getOntologyStatus(ontology);
+    return c.json({ noteCount, edgeCount, summary });
+  });
+  return app;
+}
+
+// src/server/index.ts
+function createApp(options) {
+  const app = new Hono12();
+  const sessionManager = new SessionManager();
+  app.route("/api/sessions", createSessionRoutes(sessionManager, options));
+  app.route("/api/events", createEventRoutes(sessionManager));
+  app.route("/api/questions", createQuestionRoutes(sessionManager));
+  app.route("/api/updates", createUpdateRoutes(sessionManager));
+  app.route("/api/snapshots", createSnapshotRoutes(sessionManager));
+  app.route("/api/workspace", createWorkspaceRoutes());
+  app.route("/api/auth", createAuthRoutes(options));
+  app.route("/api/config", createConfigRoutes(options));
+  app.route("/api/skills", createSkillRoutes(options));
+  app.route("/api/memory", createMemoryRoutes(options));
+  app.route("/api/ontology", createOntologyRoutes());
+  app.get("/api/health", (c) => c.json({ status: "ok" }));
+  return { app, sessionManager };
+}
+
+export {
+  createApp
+};