open-research 0.1.8 → 0.1.10

package/dist/cli.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import React4 from "react";
-import path19 from "path";
+import path21 from "path";
 import { Command } from "commander";
 import { render } from "ink";
 
@@ -811,7 +811,7 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "0.1.8";
+var PACKAGE_VERSION = "0.1.10";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
@@ -860,7 +860,7 @@ async function ensureOpenResearchConfig(options) {
 }
 
 // src/tui/app.tsx
-import path18 from "path";
+import path20 from "path";
 import {
   startTransition,
   useDeferredValue,
@@ -4929,6 +4929,72 @@ async function extractAndStoreMemories(input2) {
   return stored;
 }
 
+// src/lib/workspace/agents-md.ts
+import fs15 from "fs/promises";
+import path14 from "path";
+var AGENTS_MD_FILENAME = "AGENTS.md";
+async function readAgentsMd(workspaceDir) {
+  try {
+    return await fs15.readFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function writeAgentsMd(workspaceDir, content) {
+  await fs15.writeFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), content, "utf8");
+}
+var UPDATE_SYSTEM_PROMPT = `You maintain an AGENTS.md file for a research workspace. This file gives future agent sessions instant context about the project \u2014 what it's about, what's been done, key files, and current direction.
+
+You will receive:
+1. The current AGENTS.md content (may be empty on first run)
+2. A summary of what just happened in the latest conversation turn
+
+Your job: decide if AGENTS.md should be updated based on the new information. If yes, output the FULL updated AGENTS.md content. If nothing meaningful changed, output exactly "NO_UPDATE".
+
+Rules:
+- Keep it concise \u2014 under 2000 characters. This gets injected into every system prompt.
+- Structure: Project overview \u2192 Key files \u2192 Current state \u2192 Research direction
+- Only include information that helps a NEW agent session pick up where this one left off
+- Don't include conversation-specific details \u2014 only durable project knowledge
+- Update incrementally \u2014 preserve existing content, add/modify what changed
+- Use markdown with ## headings`;
+var UPDATE_USER_TEMPLATE = `Current AGENTS.md:
+---
+{CURRENT_CONTENT}
+---
+
+Latest turn summary:
+User asked: {USER_MESSAGE}
+Agent did: {AGENT_SUMMARY}
+
+Should AGENTS.md be updated? If yes, output the full updated content. If no meaningful project-level changes, output exactly "NO_UPDATE".`;
+async function maybeUpdateAgentsMd(input2) {
+  if (input2.userMessage.length < 15) return false;
+  if (input2.userMessage.startsWith("/")) return false;
+  const currentContent = await readAgentsMd(input2.workspaceDir);
+  const userPrompt = UPDATE_USER_TEMPLATE.replace("{CURRENT_CONTENT}", currentContent || "(empty \u2014 first time)").replace("{USER_MESSAGE}", input2.userMessage.slice(0, 500)).replace("{AGENT_SUMMARY}", input2.agentResponse.slice(0, 1500));
+  try {
+    const response = await input2.provider.callLLM({
+      messages: [
+        { role: "system", content: UPDATE_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ],
+      model: input2.model ?? "gpt-5.4-mini",
+      maxTokens: 2048,
+      temperature: 0
+    });
+    const result = response.content.trim();
+    if (result === "NO_UPDATE" || result.length < 20) {
+      return false;
+    }
+    const cleaned = result.replace(/^```(?:markdown)?\n?/, "").replace(/\n?```$/, "").trim();
+    await writeAgentsMd(input2.workspaceDir, cleaned);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/agent/runtime.ts
 var TOOL_DESCRIPTIONS = {
   read_file: (a) => `Reading ${a.file_path ?? "file"}`,
@@ -5019,7 +5085,14 @@ async function runAgentTurn(input2) {
   const usage = input2.sessionUsage ?? createSessionUsage();
   const memories = await loadMemories({ homeDir: input2.homeDir });
   const memoryBlock = formatMemoriesForPrompt(memories);
-  const fullSystemPrompt = memoryBlock ? systemPrompt + "\n\n" + memoryBlock : systemPrompt;
+  const agentsMd = input2.workspace.workspaceDir ? await readAgentsMd(input2.workspace.workspaceDir).catch(() => "") : "";
+  const contextBlocks = [
+    systemPrompt,
+    memoryBlock ? memoryBlock : null,
+    agentsMd ? `## Project Context (from AGENTS.md)
+${agentsMd}` : null
+  ].filter(Boolean).join("\n\n");
+  const fullSystemPrompt = contextBlocks;
   let messages = [
     { role: "system", content: fullSystemPrompt },
     ...input2.history,
@@ -5086,6 +5159,18 @@ async function runAgentTurn(input2) {
         }
       }).catch(() => {
       });
+      if (input2.workspace.workspaceDir) {
+        maybeUpdateAgentsMd({
+          workspaceDir: input2.workspace.workspaceDir,
+          userMessage: input2.message,
+          agentResponse: fullText,
+          provider: input2.provider,
+          model: "gpt-5.4-mini"
+        }).then((updated) => {
+          if (updated) input2.onAgentsMdUpdated?.();
+        }).catch(() => {
+        });
+      }
       return {
         text: fullText,
         proposedUpdates,
@@ -5177,8 +5262,8 @@ function classifyUpdateRisk(update) {
 }
 
 // src/lib/workspace/apply-update.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 function resolveRelativePath(update) {
   if (update.key.startsWith("path:")) {
     return update.key.slice(5);
@@ -5199,20 +5284,20 @@ function resolveRelativePath(update) {
 }
 async function applyProposedUpdate(workspaceDir, update) {
   const relativePath = resolveRelativePath(update);
-  const absolutePath = path14.join(workspaceDir, relativePath);
-  await fs15.mkdir(path14.dirname(absolutePath), { recursive: true });
-  await fs15.writeFile(absolutePath, update.content, "utf8");
+  const absolutePath = path15.join(workspaceDir, relativePath);
+  await fs16.mkdir(path15.dirname(absolutePath), { recursive: true });
+  await fs16.writeFile(absolutePath, update.content, "utf8");
   return absolutePath;
 }
 
 // src/lib/workspace/sessions.ts
-import fs16 from "fs/promises";
-import path15 from "path";
+import fs17 from "fs/promises";
+import path16 from "path";
 async function appendSessionEvent(workspaceDir, sessionId, event) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  await fs16.mkdir(sessionsDir, { recursive: true });
-  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
-  await fs16.appendFile(sessionFile, `${JSON.stringify(event)}
+  await fs17.mkdir(sessionsDir, { recursive: true });
+  const sessionFile = path16.join(sessionsDir, `${sessionId}.jsonl`);
+  await fs17.appendFile(sessionFile, `${JSON.stringify(event)}
 `, "utf8");
 }
 function parseEvents(raw) {
@@ -5228,7 +5313,7 @@ async function listSessions(workspaceDir) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
   let files;
   try {
-    files = await fs16.readdir(sessionsDir);
+    files = await fs17.readdir(sessionsDir);
   } catch {
     return [];
   }
@@ -5236,7 +5321,7 @@ async function listSessions(workspaceDir) {
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
     const id = file.replace(/\.jsonl$/, "");
-    const raw = await fs16.readFile(path15.join(sessionsDir, file), "utf8");
+    const raw = await fs17.readFile(path16.join(sessionsDir, file), "utf8");
     const events = parseEvents(raw);
     if (events.length === 0) continue;
     const chatTurns = events.filter((e) => e.type === "chat.turn");
@@ -5257,8 +5342,8 @@ async function listSessions(workspaceDir) {
 }
 async function loadSessionHistory(workspaceDir, sessionId) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
-  const raw = await fs16.readFile(sessionFile, "utf8");
+  const sessionFile = path16.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await fs17.readFile(sessionFile, "utf8");
   const events = parseEvents(raw);
   const messages = [];
   const llmHistory = [];
@@ -5370,15 +5455,15 @@ function ConfigScreen({ items, onUpdate, onClose }) {
 }
 
 // src/lib/cli/update-check.ts
-import fs17 from "fs/promises";
-import path16 from "path";
+import fs18 from "fs/promises";
+import path17 from "path";
 import os4 from "os";
 var PACKAGE_NAME = "open-research";
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-var STATE_FILE = path16.join(os4.homedir(), ".open-research", "update-check.json");
+var STATE_FILE = path17.join(os4.homedir(), ".open-research", "update-check.json");
 async function readState() {
   try {
-    const raw = await fs17.readFile(STATE_FILE, "utf8");
+    const raw = await fs18.readFile(STATE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       lastCheck: typeof parsed.lastCheck === "number" ? parsed.lastCheck : 0,
@@ -5390,8 +5475,8 @@ async function readState() {
   }
 }
 async function writeState(state) {
-  await fs17.mkdir(path16.dirname(STATE_FILE), { recursive: true });
-  await fs17.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
+  await fs18.mkdir(path17.dirname(STATE_FILE), { recursive: true });
+  await fs18.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
 }
 function getCurrentVersion() {
   return getPackageVersion();
@@ -5443,10 +5528,158 @@ async function checkForUpdate() {
   }
 }
 
+// src/lib/workspace/init-agents-md.ts
+import fs19 from "fs/promises";
+import path18 from "path";
+var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".cache",
+  "target",
+  ".open-research",
+  "coverage"
+]);
+var INTERESTING_FILES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "requirements.txt",
+  "setup.py",
+  "setup.cfg",
+  "README.md",
+  "README.txt",
+  "readme.md",
+  "Makefile",
+  "Dockerfile",
+  "docker-compose.yml",
+  ".env.example",
+  "tsconfig.json",
+  "vitest.config.ts",
+  "jest.config.js",
+  "AGENTS.md"
+]);
+async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
+  const results = [];
+  if (depth > maxDepth) return results;
+  try {
+    const entries = await fs19.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (IGNORED_DIRS2.has(entry.name)) continue;
+      if (entry.name.startsWith(".") && depth === 0 && entry.isDirectory()) continue;
+      const fullPath = path18.join(dir, entry.name);
+      const relativePath = path18.relative(dir, fullPath);
+      if (entry.isDirectory()) {
+        results.push({ path: relativePath + "/", size: 0, isDir: true });
+        const children = await scanDirectoryShallow(fullPath, maxDepth, depth + 1);
+        results.push(...children);
+      } else {
+        const stat = await fs19.stat(fullPath).catch(() => null);
+        results.push({ path: relativePath, size: stat?.size ?? 0, isDir: false });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+async function readKeyFiles(dir) {
+  const contents = {};
+  for (const name of INTERESTING_FILES) {
+    try {
+      const content = await fs19.readFile(path18.join(dir, name), "utf8");
+      contents[name] = content.slice(0, 2e3);
+    } catch {
+    }
+  }
+  return contents;
+}
+var CREATE_PROMPT = `You are creating an AGENTS.md file for a research workspace. This file is injected into an AI research agent's system prompt every session to give it instant project context.
+
+Write a concise AGENTS.md covering:
+## Project Overview \u2014 What is this project? What research?
+## Structure \u2014 Key directories and their purpose (only important ones)
+## Key Files \u2014 Notable files and what they do
+## Research Context \u2014 What research is in progress?
+## Development \u2014 How to build/run/test (if applicable)
+
+Rules:
+- Under 1500 characters. This goes into every system prompt.
+- Specific to THIS project. No generic advice.
+- Markdown with ## headings.`;
+var UPDATE_PROMPT = `You are updating an existing AGENTS.md file for a research workspace. This file is injected into an AI research agent's system prompt every session.
+
+You have:
+1. The CURRENT AGENTS.md content
+2. A fresh scan of the workspace directory and key files
+
+Your job: compare the current AGENTS.md against the actual workspace state. Update it to reflect reality:
+- Add new directories/files that appeared
+- Remove references to things that no longer exist
+- Update descriptions that are now outdated
+- Preserve any manually-added notes or context the user wrote
+- Keep the same ## heading structure
+
+If AGENTS.md is already accurate, output it unchanged.
+
+Rules:
+- Under 1500 characters. This goes into every system prompt.
+- Output the FULL updated AGENTS.md content, not a diff.
+- Markdown with ## headings.`;
+async function generateInitialAgentsMd(input2) {
+  const dir = input2.workspaceDir;
+  const files = await scanDirectoryShallow(dir);
+  const tree = files.slice(0, 100).map((f) => `${f.isDir ? "d" : "f"} ${f.path}${f.size > 0 ? ` (${(f.size / 1024).toFixed(1)}KB)` : ""}`).join("\n");
+  const keyFiles = await readKeyFiles(dir);
+  const keyFileText = Object.entries(keyFiles).map(([name, content2]) => `### ${name}
+\`\`\`
+${content2}
+\`\`\``).join("\n\n");
+  const scanData = `Directory: ${dir}
+
+File tree:
+${tree}
+
+${keyFileText || "No recognizable key files found."}`;
+  const existing = await readAgentsMd(dir);
+  let systemPrompt;
+  let userMessage;
+  if (existing) {
+    systemPrompt = UPDATE_PROMPT;
+    userMessage = `Current AGENTS.md:
+---
+${existing}
+---
+
+Fresh workspace scan:
+${scanData.slice(0, 25e3)}`;
+  } else {
+    systemPrompt = CREATE_PROMPT;
+    userMessage = scanData.slice(0, 25e3);
+  }
+  const response = await input2.provider.callLLM({
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ],
+    model: input2.model ?? "gpt-5.4-mini",
+    maxTokens: 2048,
+    temperature: 0
+  });
+  const content = response.content.replace(/^```(?:markdown)?\n?/, "").replace(/\n?```$/, "").trim();
+  await writeAgentsMd(dir, content);
+  return content;
+}
+
 // src/lib/preview/server.ts
 import http2 from "http";
-import fs18 from "fs";
-import path17 from "path";
+import fs20 from "fs";
+import path19 from "path";
 
 // src/lib/preview/latex-to-html.ts
 function latexToHtml(latex) {
@@ -5713,11 +5946,11 @@ var HTML_TEMPLATE = `<!DOCTYPE html>
 </body>
 </html>`;
 function startPreviewServer(texPath) {
-  const resolved = path17.resolve(texPath);
+  const resolved = path19.resolve(texPath);
   let currentHash = "";
   function getContentHash() {
     try {
-      const content = fs18.readFileSync(resolved, "utf8");
+      const content = fs20.readFileSync(resolved, "utf8");
       return `${content.length}-${content.slice(0, 100)}-${content.slice(-100)}`;
     } catch {
       return "error";
@@ -5725,7 +5958,7 @@ function startPreviewServer(texPath) {
   }
   function renderPage() {
     try {
-      const latex = fs18.readFileSync(resolved, "utf8");
+      const latex = fs20.readFileSync(resolved, "utf8");
       const htmlContent = latexToHtml(latex);
       currentHash = getContentHash();
       return HTML_TEMPLATE.replace("{{CONTENT}}", htmlContent);
@@ -6472,23 +6705,32 @@ function App({
       }
       case "init": {
         const target = process.cwd();
-        const existing = await loadWorkspaceProject(target);
-        if (existing) {
-          addSystemMessage(`Already a workspace: ${target}`);
+        setBusy(true);
+        try {
+          const existing = await loadWorkspaceProject(target);
+          if (!existing) {
+            await initWorkspace({ workspaceDir: target });
+            addSystemMessage(`Workspace initialized at ${target}`);
+          }
           setWorkspacePath(target);
-        } else {
-          setBusy(true);
-          try {
-            const project = await initWorkspace({ workspaceDir: target });
-            setWorkspacePath(target);
-            addSystemMessage(`Initialized workspace "${project.title}" at ${target}`);
-            const scanned = await scanWorkspace(target);
-            startTransition(() => setWorkspaceFiles(scanned.files));
-          } catch (err) {
-            addSystemMessage(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
-          } finally {
-            setBusy(false);
+          if (!hasAuth) {
+            addSystemMessage("Run /auth first \u2014 AGENTS.md generation requires auth.");
+            break;
           }
+          addSystemMessage("Scanning workspace and updating AGENTS.md...");
+          const provider = await createProviderFromStoredAuth({ homeDir });
+          const result = await generateInitialAgentsMd({
+            workspaceDir: target,
+            provider,
+            model: "gpt-5.4-mini"
+          });
+          addSystemMessage("AGENTS.md ready. Project context will load on every session.");
+          const scanned = await scanWorkspace(target);
+          startTransition(() => setWorkspaceFiles(scanned.files));
+        } catch (err) {
+          addSystemMessage(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          setBusy(false);
         }
         break;
       }
@@ -7001,6 +7243,7 @@ ${msg.text}
       const provider = await createProviderFromStoredAuth({ homeDir });
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
+        workspaceDir: workspacePath,
         runId: sessionId,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
@@ -7133,6 +7376,7 @@ ${msg.text}
       const provider = await createProviderFromStoredAuth({ homeDir });
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
+        workspaceDir: workspacePath,
         runId: sessionId,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
@@ -7478,7 +7722,7 @@ ${msg.text}
         statusParts,
         statusColor,
         tokenDisplay,
-        workspaceName: hasWorkspace ? path18.basename(workspacePath) : process.cwd(),
+        workspaceName: hasWorkspace ? path20.basename(workspacePath) : process.cwd(),
         mode: agentMode,
         planningStatus: planningState.status
       }
@@ -7490,7 +7734,7 @@ ${msg.text}
 var program = new Command();
 program.name("open-research").version(getPackageVersion()).description("Local-first research CLI powered by ChatGPT/Codex auth.").argument("[workspacePath]", "Optional workspace path to open").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = workspacePath ? path19.resolve(workspacePath) : process.cwd();
+  const target = workspacePath ? path21.resolve(workspacePath) : process.cwd();
   const project = await loadWorkspaceProject(target);
   const auth2 = await loadStoredAuth();
   render(
@@ -7506,7 +7750,7 @@ program.name("open-research").version(getPackageVersion()).description("Local-fi
 });
 program.command("init").argument("[workspacePath]").description("Initialize an Open Research workspace.").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = path19.resolve(workspacePath ?? process.cwd());
+  const target = path21.resolve(workspacePath ?? process.cwd());
   const project = await initWorkspace({ workspaceDir: target });
   console.log(`Initialized workspace: ${target}`);
   console.log(`Title: ${project.title}`);
@@ -7575,8 +7819,8 @@ skills.command("create").argument("[name]").description("Scaffold a new user ski
 });
 skills.command("edit").argument("<name>").description("Open a user skill in $EDITOR.").action(async (name) => {
   await ensureOpenResearchConfig();
-  const skillDir = path19.join(getOpenResearchSkillsDir(), name);
-  openInEditor(path19.join(skillDir, "SKILL.md"));
+  const skillDir = path21.join(getOpenResearchSkillsDir(), name);
+  openInEditor(path21.join(skillDir, "SKILL.md"));
   const validation = await validateSkillDirectory({ skillDir });
   if (!validation.ok) {
     console.error(validation.errors.join("\n"));
@@ -7587,9 +7831,9 @@ skills.command("edit").argument("<name>").description("Open a user skill in $EDI
 });
 skills.command("validate").argument("[nameOrPath]").description("Validate one user skill.").action(async (nameOrPath) => {
   await ensureOpenResearchConfig();
-  const skillDir = nameOrPath ? path19.isAbsolute(nameOrPath) ? nameOrPath : path19.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
+  const skillDir = nameOrPath ? path21.isAbsolute(nameOrPath) ? nameOrPath : path21.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
   const stat = await import("fs/promises").then(
-    (fs19) => fs19.stat(skillDir).catch(() => null)
+    (fs21) => fs21.stat(skillDir).catch(() => null)
   );
   if (!stat) {
     throw new Error(`Skill path not found: ${skillDir}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Local-first research CLI agent — discover papers, synthesize notes, run analysis, and draft artifacts from your terminal.",
   "type": "module",
   "license": "MIT",