open-research 0.1.26 → 1.0.0

package/dist/manager-queue-F4VVZMTE.js

@@ -0,0 +1,608 @@
+import {
+  loadOntology,
+  saveOntology
+} from "./chunk-3WM33M3O.js";
+import {
+  DEFAULT_CONFIDENCE
+} from "./chunk-KJHM7ZW2.js";
+import {
+  getConnections,
+  getNote,
+  searchNotes
+} from "./chunk-IOR7G25X.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/ontology/write-tools.ts
+function createNote(ontology, params) {
+  const noteId = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const note = {
+    id: noteId,
+    content: params.content,
+    kind: params.kind,
+    confidence: params.confidence ?? DEFAULT_CONFIDENCE[params.kind],
+    meta: params.kind === "source" ? params.meta : void 0,
+    edges: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  ontology.notes.push(note);
+  return { ontology, noteId };
+}
+function createEdge(ontology, params) {
+  const sourceNote = ontology.notes.find((n) => n.id === params.sourceNoteId);
+  if (!sourceNote) {
+    throw new Error(`Source note not found: ${params.sourceNoteId}`);
+  }
+  const targetExists = ontology.notes.some((n) => n.id === params.targetNoteId);
+  if (!targetExists) {
+    throw new Error(`Target note not found: ${params.targetNoteId}`);
+  }
+  const duplicate = sourceNote.edges.find(
+    (e) => e.targetId === params.targetNoteId && e.relation === params.relation
+  );
+  if (duplicate) {
+    throw new Error(
+      `Edge already exists: ${params.sourceNoteId} \u2192 ${params.targetNoteId} (${params.relation})`
+    );
+  }
+  sourceNote.edges.push({
+    targetId: params.targetNoteId,
+    relation: params.relation,
+    strength: params.strength,
+    direction: params.direction,
+    context: params.context
+  });
+  sourceNote.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const edgeId = `${params.sourceNoteId}\u2192${params.targetNoteId}:${params.relation}`;
+  return { ontology, edgeId };
+}
+function updateNote(ontology, params) {
+  const note = ontology.notes.find((n) => n.id === params.noteId);
+  if (!note) throw new Error(`Note not found: ${params.noteId}`);
+  if (params.content !== void 0) note.content = params.content;
+  if (params.confidence !== void 0) note.confidence = params.confidence;
+  note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return ontology;
+}
+function updateEdge(ontology, params) {
+  const sourceNote = ontology.notes.find((n) => n.id === params.sourceNoteId);
+  if (!sourceNote) throw new Error(`Source note not found: ${params.sourceNoteId}`);
+  const edge = sourceNote.edges.find(
+    (e) => e.targetId === params.targetNoteId && e.relation === params.relation
+  );
+  if (!edge) {
+    throw new Error(
+      `Edge not found: ${params.sourceNoteId} \u2192 ${params.targetNoteId} (${params.relation})`
+    );
+  }
+  if (params.strength !== void 0) edge.strength = params.strength;
+  if (params.context !== void 0) edge.context = params.context;
+  sourceNote.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return ontology;
+}
+function removeEdge(ontology, params) {
+  const sourceNote = ontology.notes.find((n) => n.id === params.sourceNoteId);
+  if (!sourceNote) throw new Error(`Source note not found: ${params.sourceNoteId}`);
+  const idx = sourceNote.edges.findIndex(
+    (e) => e.targetId === params.targetNoteId && e.relation === params.relation
+  );
+  if (idx === -1) {
+    throw new Error(
+      `Edge not found: ${params.sourceNoteId} \u2192 ${params.targetNoteId} (${params.relation})`
+    );
+  }
+  sourceNote.edges.splice(idx, 1);
+  sourceNote.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return ontology;
+}
+var STRENGTH_RANK = {
+  strong: 3,
+  moderate: 2,
+  weak: 1
+};
+function mergeNotes(ontology, params) {
+  const keepNote = ontology.notes.find((n) => n.id === params.keepNoteId);
+  if (!keepNote) throw new Error(`Keep note not found: ${params.keepNoteId}`);
+  const removeNote = ontology.notes.find((n) => n.id === params.removeNoteId);
+  if (!removeNote) throw new Error(`Remove note not found: ${params.removeNoteId}`);
+  let edgesRedirected = 0;
+  for (const note of ontology.notes) {
+    if (note.id === params.removeNoteId) continue;
+    for (const edge of note.edges) {
+      if (edge.targetId === params.removeNoteId) {
+        edge.targetId = params.keepNoteId;
+        edgesRedirected++;
+      }
+    }
+  }
+  for (const edge of removeNote.edges) {
+    const targetId = edge.targetId === params.removeNoteId ? params.keepNoteId : edge.targetId;
+    if (targetId === params.keepNoteId) continue;
+    const existing = keepNote.edges.find(
+      (e) => e.targetId === targetId && e.relation === edge.relation
+    );
+    if (existing) {
+      if (STRENGTH_RANK[edge.strength] > STRENGTH_RANK[existing.strength]) {
+        existing.strength = edge.strength;
+        existing.context = edge.context;
+      }
+    } else {
+      keepNote.edges.push({ ...edge, targetId });
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of keepNote.edges) {
+    const key = `${edge.targetId}:${edge.relation}`;
+    const existing = edgeMap.get(key);
+    if (!existing || STRENGTH_RANK[edge.strength] > STRENGTH_RANK[existing.strength]) {
+      edgeMap.set(key, edge);
+    }
+  }
+  keepNote.edges = [...edgeMap.values()];
+  if (params.mergedContent) {
+    keepNote.content = params.mergedContent;
+  }
+  keepNote.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  ontology.notes = ontology.notes.filter((n) => n.id !== params.removeNoteId);
+  return { ontology, edgesRedirected };
+}
+
+// src/lib/ontology/manager.ts
+var SYSTEM_PROMPT = `You are the Ontology Manager. You maintain the structured knowledge graph for a research project.
+
+# Your single job
+
+After each conversation turn, you receive the researcher's message, the AI assistant's response, and any tool outputs. You decide what substantive knowledge to extract and how to structure it in the ontology.
+
+You output ONLY tool calls. No conversational text. When you're done, stop calling tools \u2014 that signals completion.
+
+# Decision process
+
+For each turn, follow this sequence:
+
+1. READ the turn. Identify any substantive knowledge: new sources, findings, claims, methods, questions, or insights.
+2. SKIP if the turn contains only chitchat, UI commands, greetings, or meta-conversation. Outputting 0 operations is correct.
+3. SEARCH before writing. For every piece of knowledge you want to capture, first call search_notes to check if it already exists. Duplicate notes degrade the entire system.
+4. WRITE only what's new. Create notes, add edges, or update existing notes. Typical turn: 1-5 operations.
+
+# Note kinds
+
+| Kind | What it captures | Required edges |
+|------|-----------------|----------------|
+| source | A citable origin: paper, URL, dataset, book | None |
+| finding | A specific result from a source | MUST have derived-from \u2192 source |
+| claim | An argument or assertion in the research | None (but should accumulate supports/contradicts over time) |
+| question | An open gap, uncertainty, or research question | None |
+| method | A methodology or analytical technique | None |
+| insight | A synthesis connecting multiple findings/claims | SHOULD have derived-from \u2192 the findings/claims it synthesizes |
+
+# Edge creation \u2014 decision tree
+
+When connecting two notes, use this decision tree:
+
+Is note A direct provenance for note B? (A was extracted from B, or B was synthesized from A)
+  \u2192 YES: derived-from (directed, A \u2192 B)
+
+Does note A provide direct empirical evidence that tests what note B claims?
+  \u2192 YES: supports (directed, A \u2192 B)
+  \u2192 A is merely about the same topic as B: relates-to (NOT supports)
+
+Do notes A and B assert things that CANNOT BOTH BE TRUE about the same variable, measured in comparable conditions?
+  \u2192 YES: contradicts (mutual)
+  \u2192 They measure different things, or use different conditions: relates-to (NOT contradicts)
+
+None of the above, but genuinely connected?
+  \u2192 relates-to (mutual)
+
+## Edge context \u2014 good vs bad
+
+The context field explains WHY the connection exists. It must add information beyond the relation type.
+
+GOOD:
+- "Table 3 reports 12% BLEU improvement on WMT14 EN-DE (p<0.01), directly testing the scaling hypothesis under identical conditions"
+- "Chen used 10x larger training data and observed inverse scaling, suggesting the original finding is dataset-size-dependent"
+- "Synthesized from the sample-size observation (Smith) and the scaling curve (Jones) to hypothesize diminishing returns above 10B parameters"
+
+BAD:
+- "supports the claim" (redundant \u2014 the relation field already says this)
+- "related" (says nothing)
+- "from this paper" (the edge already points to the source)
+
+# Confidence
+
+Only change confidence when the conversation provides EXPLICIT evidence. Do not infer from tone or speculation. When uncertain, leave unchanged.
+
+Defaults: source/finding/method \u2192 established | claim/insight \u2192 hypothesized | question \u2192 questioned
+
+# Critical constraint
+
+A wrong edge is worse than a missing edge. Missing edges can be added later. Wrong edges actively mislead the researcher's analysis. When uncertain about an edge type, use relates-to with explanatory context, or skip the edge entirely.`;
+var MANAGER_TOOLS = [
+  // ── Read tools ───────────────────────────────────────────────────────
+  {
+    type: "function",
+    function: {
+      name: "get_note",
+      description: "Retrieve a single note by ID. Returns its content, kind, confidence, all edges, and source metadata. Use when you already have a note ID from search results or edge targets.",
+      parameters: {
+        type: "object",
+        properties: {
+          noteId: { type: "string", description: "UUID of the note to retrieve" }
+        },
+        required: ["noteId"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "search_notes",
+      description: "Find notes by text and/or structure. ALWAYS call this before create_note to check for duplicates. Combine text queries with structural filters for precise results. Example: find unsupported claims \u2192 { kind: 'claim', missingEdge: 'supports' }. Example: find a paper \u2192 { queries: ['Smith 2024', 'attention scaling'], kind: 'source' }.",
+      parameters: {
+        type: "object",
+        properties: {
+          queries: {
+            type: "array",
+            items: { type: "string" },
+            description: "Text search phrases (OR logic). Include 2-3 phrasings to cover synonyms. E.g. ['transformer efficiency', 'attention scaling', 'BLEU improvement']"
+          },
+          kind: { type: "string", enum: ["source", "finding", "claim", "question", "method", "insight"] },
+          confidence: { type: "string", enum: ["established", "supported", "hypothesized", "questioned", "refuted"] },
+          hasEdge: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"], description: "Note must have at least one outgoing or incoming mutual edge of this type" },
+          missingEdge: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"], description: "Note must have NO edges of this type" },
+          limit: { type: "number", description: "Max results. Default: 10" }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_connections",
+      description: "Explore a note's neighborhood. Returns the note and all notes connected within N hops. Call this BEFORE creating edges to understand what's already connected. Also useful for finding notes that search_notes missed \u2014 follow edges to discover related notes.",
+      parameters: {
+        type: "object",
+        properties: {
+          noteId: { type: "string", description: "Starting note ID" },
+          depth: { type: "number", description: "Hops to traverse. Default: 1, max: 3. Use 1 for immediate neighbors, 2 for extended context." }
+        },
+        required: ["noteId"],
+        additionalProperties: false
+      }
+    }
+  },
+  // ── Write tools ──────────────────────────────────────────────────────
+  {
+    type: "function",
+    function: {
+      name: "create_note",
+      description: "Create a new note in the ontology. PREREQUISITE: You must call search_notes first to verify this note doesn't already exist. If a similar note exists, use update_note or create_edge instead. For findings: you MUST create a derived-from edge to the source immediately after.",
+      parameters: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "Clear, factual description in 1-3 sentences. Be specific \u2014 include numbers, conditions, and qualifiers." },
+          kind: { type: "string", enum: ["source", "finding", "claim", "question", "method", "insight"] },
+          confidence: { type: "string", enum: ["established", "supported", "hypothesized", "questioned", "refuted"], description: "Omit to use default for the kind" },
+          meta: {
+            type: "object",
+            description: "Citation metadata. Only for kind: 'source'. Include as many fields as available.",
+            properties: {
+              authors: { type: "string", description: "Author names, e.g. 'Vaswani, Shazeer, Parmar, et al.'" },
+              year: { type: "number" },
+              venue: { type: "string", description: "Publication venue, e.g. 'NeurIPS 2017'" },
+              url: { type: "string" },
+              doi: { type: "string" },
+              filePath: { type: "string", description: "Workspace-relative path to the file, e.g. 'sources/vaswani-2017.pdf'" }
+            },
+            additionalProperties: false
+          }
+        },
+        required: ["content", "kind"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "create_edge",
+      description: "Connect two notes with a typed, directional relationship. Follow the edge decision tree in your instructions. Key rules: supports/derived-from are always 'directed'. contradicts/relates-to are always 'mutual'. The context field must explain WHY \u2014 not just restate the relation.",
+      parameters: {
+        type: "object",
+        properties: {
+          sourceNoteId: { type: "string", description: "ID of the FROM note" },
+          targetNoteId: { type: "string", description: "ID of the TO note" },
+          relation: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"] },
+          strength: {
+            type: "string",
+            enum: ["strong", "moderate", "weak"],
+            description: "strong = direct, unambiguous connection. moderate = relevant but indirect. weak = tangential."
+          },
+          direction: {
+            type: "string",
+            enum: ["directed", "mutual"],
+            description: "directed: supports, derived-from (A\u2192B only). mutual: contradicts, relates-to (bidirectional)."
+          },
+          context: {
+            type: "string",
+            description: "Explain WHY this connection exists with specific details. Must add information beyond the relation type. Include page numbers, table references, conditions, or reasoning."
+          }
+        },
+        required: ["sourceNoteId", "targetNoteId", "relation", "strength", "direction", "context"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "update_note",
+      description: "Modify a note's content or confidence. Use when new information refines, extends, or corrects an existing note rather than creating a duplicate.",
+      parameters: {
+        type: "object",
+        properties: {
+          noteId: { type: "string" },
+          content: { type: "string", description: "Replacement content. Omit to keep current." },
+          confidence: { type: "string", enum: ["established", "supported", "hypothesized", "questioned", "refuted"], description: "New confidence level. Only change with explicit evidence. Omit to keep current." }
+        },
+        required: ["noteId"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "update_edge",
+      description: "Modify an existing edge's strength or context. Use when new evidence changes the strength of a connection, or when context needs to be enriched.",
+      parameters: {
+        type: "object",
+        properties: {
+          sourceNoteId: { type: "string" },
+          targetNoteId: { type: "string" },
+          relation: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"], description: "Identifies which edge to update (source + target + relation is unique)" },
+          strength: { type: "string", enum: ["strong", "moderate", "weak"] },
+          context: { type: "string" }
+        },
+        required: ["sourceNoteId", "targetNoteId", "relation"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "remove_edge",
+      description: "Delete an edge that was created incorrectly. Only use when the relationship is definitively wrong \u2014 not just weak.",
+      parameters: {
+        type: "object",
+        properties: {
+          sourceNoteId: { type: "string" },
+          targetNoteId: { type: "string" },
+          relation: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"] }
+        },
+        required: ["sourceNoteId", "targetNoteId", "relation"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "merge_notes",
+      description: "Combine two duplicate notes into one. All edges pointing to the removed note are redirected to the kept note. Duplicate edges are deduplicated (strongest wins). Use when search reveals the same knowledge was captured twice.",
+      parameters: {
+        type: "object",
+        properties: {
+          keepNoteId: { type: "string", description: "ID of the note to keep (usually the more complete one)" },
+          removeNoteId: { type: "string", description: "ID of the note to remove \u2014 its edges will be redirected" },
+          mergedContent: { type: "string", description: "Optional: replacement content that combines both notes' information" }
+        },
+        required: ["keepNoteId", "removeNoteId"],
+        additionalProperties: false
+      }
+    }
+  }
+];
+function executeManagerTool(name, args, ontology) {
+  try {
+    switch (name) {
+      // Read tools
+      case "get_note": {
+        const note = getNote(ontology, String(args.noteId));
+        if (!note) return { result: `Note not found: ${args.noteId}`, ontology };
+        return { result: JSON.stringify(note, null, 2), ontology };
+      }
+      case "search_notes": {
+        const results = searchNotes(ontology, {
+          queries: args.queries,
+          kind: args.kind,
+          confidence: args.confidence,
+          hasEdge: args.hasEdge,
+          missingEdge: args.missingEdge,
+          limit: args.limit
+        });
+        if (results.length === 0) return { result: "No matching notes found.", ontology };
+        return {
+          result: results.map(
+            (n) => `[${n.id}] (${n.kind}, ${n.confidence}) "${n.content}" \u2014 ${n.edges.length} edges`
+          ).join("\n"),
+          ontology
+        };
+      }
+      case "get_connections": {
+        const { root, connected } = getConnections(
+          ontology,
+          String(args.noteId),
+          args.depth ?? 1
+        );
+        if (!root) return { result: `Note not found: ${args.noteId}`, ontology };
+        const lines = [
+          `Root: [${root.id}] (${root.kind}) "${root.content}"`,
+          `Edges: ${root.edges.map((e) => `${e.relation} \u2192 ${e.targetId.slice(0, 8)}`).join(", ") || "none"}`,
+          `Connected (${connected.length}):`,
+          ...connected.map((c) => `  [${c.id}] (${c.kind}) "${c.content}"`)
+        ];
+        return { result: lines.join("\n"), ontology };
+      }
+      // Write tools
+      case "create_note": {
+        const { ontology: updated, noteId } = createNote(ontology, {
+          content: String(args.content),
+          kind: String(args.kind),
+          confidence: args.confidence,
+          meta: args.meta
+        });
+        return { result: `Created note: ${noteId}`, ontology: updated };
+      }
+      case "create_edge": {
+        const { ontology: updated, edgeId } = createEdge(ontology, {
+          sourceNoteId: String(args.sourceNoteId),
+          targetNoteId: String(args.targetNoteId),
+          relation: String(args.relation),
+          strength: String(args.strength),
+          direction: String(args.direction),
+          context: String(args.context)
+        });
+        return { result: `Created edge: ${edgeId}`, ontology: updated };
+      }
+      case "update_note": {
+        const updated = updateNote(ontology, {
+          noteId: String(args.noteId),
+          content: args.content,
+          confidence: args.confidence
+        });
+        return { result: `Updated note: ${args.noteId}`, ontology: updated };
+      }
+      case "update_edge": {
+        const updated = updateEdge(ontology, {
+          sourceNoteId: String(args.sourceNoteId),
+          targetNoteId: String(args.targetNoteId),
+          relation: String(args.relation),
+          strength: args.strength,
+          context: args.context
+        });
+        return { result: `Updated edge.`, ontology: updated };
+      }
+      case "remove_edge": {
+        const updated = removeEdge(ontology, {
+          sourceNoteId: String(args.sourceNoteId),
+          targetNoteId: String(args.targetNoteId),
+          relation: String(args.relation)
+        });
+        return { result: `Removed edge.`, ontology: updated };
+      }
+      case "merge_notes": {
+        const { ontology: updated, edgesRedirected } = mergeNotes(ontology, {
+          keepNoteId: String(args.keepNoteId),
+          removeNoteId: String(args.removeNoteId),
+          mergedContent: args.mergedContent
+        });
+        return { result: `Merged. ${edgesRedirected} edges redirected.`, ontology: updated };
+      }
+      default:
+        return { result: `Unknown tool: ${name}`, ontology };
+    }
+  } catch (err) {
+    return { result: `Error: ${err?.message ?? err}`, ontology };
+  }
+}
+var MAX_TOOL_OUTPUT_CHARS = 32e3;
+function truncateToolOutputs(outputs) {
+  if (outputs.length === 0) return "(no tool calls this turn)";
+  let total = 0;
+  const included = [];
+  for (let i = outputs.length - 1; i >= 0; i--) {
+    const entry = outputs[i];
+    const size = entry.tool.length + entry.output.length;
+    if (total + size > MAX_TOOL_OUTPUT_CHARS && included.length > 0) break;
+    included.unshift(entry);
+    total += size;
+  }
+  return included.map((o) => `[${o.tool}] ${o.output.slice(0, 4e3)}`).join("\n\n");
+}
+var MAX_ITERATIONS = 10;
+async function runOntologyManager(input) {
+  let ontology = await loadOntology(input.workspaceDir);
+  const turnSummary = [
+    `## Conversation Turn`,
+    ``,
+    `**User:** ${input.userMessage.slice(0, 3e3)}`,
+    ``,
+    `**Agent response:** ${input.agentResponse.slice(0, 3e3)}`,
+    ``,
+    `**Tool outputs:**`,
+    truncateToolOutputs(input.toolOutputs)
+  ].join("\n");
+  const messages = [
+    { role: "system", content: SYSTEM_PROMPT },
+    { role: "user", content: turnSummary }
+  ];
+  let mutated = false;
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    let fullText = "";
+    let toolCalls = [];
+    for await (const chunk of input.provider.callLLMStreaming({
+      messages,
+      tools: MANAGER_TOOLS,
+      model: "gpt-5.4"
+    })) {
+      if (chunk.type === "text_delta") {
+        fullText += chunk.content;
+      } else if (chunk.type === "done") {
+        toolCalls = chunk.toolCalls;
+      }
+    }
+    if (toolCalls.length === 0) break;
+    messages.push({
+      role: "assistant",
+      content: fullText || null,
+      tool_calls: toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const toolCall of toolCalls) {
+      const args = JSON.parse(toolCall.arguments || "{}");
+      const { result, ontology: updated } = executeManagerTool(
+        toolCall.name,
+        args,
+        ontology
+      );
+      if (updated !== ontology) mutated = true;
+      ontology = updated;
+      messages.push({
+        role: "tool",
+        tool_call_id: toolCall.id,
+        content: result
+      });
+    }
+  }
+  if (mutated) {
+    await saveOntology(ontology, input.workspaceDir);
+  }
+}
+
+// src/lib/ontology/manager-queue.ts
+var pendingWrite = Promise.resolve();
+function enqueueOntologyManager(input) {
+  pendingWrite = pendingWrite.then(() => runOntologyManager({
+    userMessage: input.userMessage,
+    agentResponse: input.agentResponse,
+    toolOutputs: input.toolOutputs,
+    provider: input.provider,
+    workspaceDir: input.workspaceDir
+  })).then(() => input.onOntologyUpdated?.()).catch((err) => {
+    if (process.env.DEBUG) {
+      process.stderr.write(`[ontology-manager] Error: ${err?.message ?? err}
+`);
+    }
+  });
+}
+export {
+  enqueueOntologyManager
+};