papergod 0.1.0

package/src/server/library-files.js

@@ -0,0 +1,134 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { loadProject } from './project-store.js';
+
+const LIBRARY_DIR = '.papergod';
+const LIBRARY_SUBDIR = 'library';
+const INDEX_FILE = 'index.json';
+
+function now() { return new Date().toISOString(); }
+
+function escapeMdInline(value) {
+  return String(value ?? '').replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&');
+}
+
+function escapeMdBlock(value) {
+  // Keep newlines; only guard against fenced code blocks and markdown headings.
+  const safe = String(value ?? '').replace(/```/g, '` ` `');
+  return safe.split('\n').map((line) => (line.startsWith('#') ? `\\${line}` : line)).join('\n');
+}
+
+function tagsLine(tags) {
+  const list = Array.isArray(tags) ? tags.filter(Boolean) : [];
+  return list.length ? list.join(', ') : '';
+}
+
+function renderCorpusMarkdown(libraries) {
+  const corpora = libraries.corpora || [];
+  const head = '# Papergod Writing Library — Corpora\n\n';
+  const body = corpora.map((item) => {
+    const blocks = [`## [${escapeMdInline(item.id)}] ${escapeMdInline(item.name)}`];
+    if (item.source) blocks.push(`- source: ${escapeMdInline(item.source)}`);
+    if (tagsLine(item.tags)) blocks.push(`- tags: ${escapeMdInline(tagsLine(item.tags))}`);
+    if (item.description) blocks.push(`- description: ${escapeMdInline(item.description)}`);
+    blocks.push('', escapeMdBlock(item.content || ''));
+    return blocks.join('\n');
+  }).join('\n\n---\n\n');
+  return head + (body || '（空库）');
+}
+
+function renderPatternsMarkdown(libraries) {
+  const patterns = libraries.sentencePatterns || [];
+  const head = '# Papergod Writing Library — Sentence Patterns\n\n';
+  const body = patterns.map((item) => {
+    const slots = (item.slots || []).map((slot) => `${slot.name}${slot.required ? '' : '?'}: ${slot.description || ''}`.trim()).join('; ');
+    const blocks = [`## [${escapeMdInline(item.id)}] ${escapeMdInline(item.name)}`];
+    if (item.source) blocks.push(`- source: ${escapeMdInline(item.source)}`);
+    if (tagsLine(item.tags)) blocks.push(`- tags: ${escapeMdInline(tagsLine(item.tags))}`);
+    if (item.sectionTypes?.length) blocks.push(`- sections: ${escapeMdInline(item.sectionTypes.join(', '))}`);
+    blocks.push(`- slots: ${escapeMdInline(slots || 'none')}`);
+    blocks.push('', `template: ${escapeMdBlock(item.template || '')}`);
+    if (item.description) blocks.push('', escapeMdBlock(item.description));
+    return blocks.join('\n');
+  }).join('\n\n---\n\n');
+  return head + (body || '（空库）');
+}
+
+function renderVocabularyMarkdown(scope) {
+  return (libraries) => {
+    const entries = (libraries.vocabulary?.[scope]) || [];
+    const head = `# Papergod Writing Library — Vocabulary (${scope})\n\n`;
+    const body = entries.map((item) => {
+      const blocks = [`## [${escapeMdInline(item.id)}] ${escapeMdInline(item.term)}${item.preferred ? ` → prefer: ${escapeMdInline(item.preferred)}` : ''}`];
+      if (item.definition) blocks.push(`- meaning: ${escapeMdInline(item.definition)}`);
+      if (item.source) blocks.push(`- source: ${escapeMdInline(item.source)}`);
+      if (tagsLine(item.tags)) blocks.push(`- tags: ${escapeMdInline(tagsLine(item.tags))}`);
+      if (item.examples?.length) blocks.push(`- examples: ${escapeMdInline(item.examples.join('; '))}`);
+      if (item.alternatives?.length) blocks.push(`- alternatives: ${escapeMdInline(item.alternatives.join(', '))}`);
+      return blocks.join('\n');
+    }).join('\n\n---\n\n');
+    return head + (body || '（空库）');
+  };
+}
+
+function summaryEntries(items, kind, file) {
+  return items.map((item) => ({
+    id: item.id,
+    kind,
+    name: item.name || item.term || item.title || '',
+    tags: Array.isArray(item.tags) ? item.tags.filter(Boolean) : [],
+    file,
+  }));
+}
+
+export const LIBRARY_FILE_LAYOUT = [
+  { kind: 'corpora', file: 'corpus.md', render: renderCorpusMarkdown, pick: (libraries) => libraries.corpora },
+  { kind: 'sentence-patterns', file: 'patterns.md', render: renderPatternsMarkdown, pick: (libraries) => libraries.sentencePatterns },
+  { kind: 'vocabulary-global', file: 'vocabulary-global.md', render: renderVocabularyMarkdown('global'), pick: (libraries) => libraries.vocabulary.global },
+  { kind: 'vocabulary-session', file: 'vocabulary-session.md', render: renderVocabularyMarkdown('session'), pick: (libraries) => libraries.vocabulary.session },
+];
+
+export function libraryDirectory(workspaceRoot) {
+  return join(workspaceRoot, LIBRARY_DIR, LIBRARY_SUBDIR);
+}
+
+export function libraryIndexPath(workspaceRoot) {
+  return join(workspaceRoot, LIBRARY_DIR, INDEX_FILE);
+}
+
+// Materialize the writing library into readable files under .papergod/library/.
+// Returns { paths, index } where `paths` is a list of relative file paths and
+// `index` is the machine-readable catalog (all entries across the four files).
+export async function materializeLibraries(workspaceRoot) {
+  const project = await loadProject(workspaceRoot);
+  const libraries = project.libraries || { corpora: [], sentencePatterns: [], vocabulary: { global: [], session: [] } };
+  const directory = libraryDirectory(workspaceRoot);
+  await mkdir(directory, { recursive: true });
+
+  const files = [];
+  const paths = [];
+  const entries = [];
+  for (const layout of LIBRARY_FILE_LAYOUT) {
+    const items = layout.pick(libraries) || [];
+    const content = layout.render(libraries);
+    const relative = `${LIBRARY_DIR}/${LIBRARY_SUBDIR}/${layout.file}`;
+    await writeFile(join(directory, layout.file), content, 'utf-8');
+    files.push({ kind: layout.kind, file: relative, count: items.length });
+    paths.push(relative);
+    entries.push(...summaryEntries(items, layout.kind, relative));
+  }
+
+  const index = {
+    generatedAt: now(),
+    files,
+    entries,
+  };
+  await writeFile(libraryIndexPath(workspaceRoot), `${JSON.stringify(index, null, 2)}\n`, 'utf-8');
+
+  return {
+    paths,
+    index,
+    directory: `.papergod/${LIBRARY_SUBDIR}`,
+    indexFile: `.papergod/${INDEX_FILE}`,
+  };
+}

package/src/server/literature-review.js

@@ -0,0 +1,122 @@
+import { randomUUID } from 'crypto';
+import { loadReferenceState } from './references.js';
+import { createAgentRun, updateAgentRun } from './project-resources.js';
+import { runWritingAgent } from './agent-adapters.js';
+
+const MAX_CITEKEYS = 30;
+const SENTINEL = '[[PAPERGOD_LITERATURE_REVIEW]]';
+
+function now() { return new Date().toISOString(); }
+function id(prefix) { return `${prefix}_${randomUUID()}`; }
+function clean(value) { return typeof value === 'string' ? value.trim() : ''; }
+function problem(message, status = 400, code = '') {
+  const error = new Error(message);
+  error.status = status;
+  if (code) error.code = code;
+  return error;
+}
+
+function authorLabel(item) {
+  const authors = Array.isArray(item.authors) ? item.authors.filter(Boolean) : [];
+  if (!authors.length) return 'Unknown authors';
+  if (authors.length === 1) return authors[0];
+  if (authors.length === 2) return `${authors[0]} and ${authors[1]}`;
+  return `${authors[0]} et al.`;
+}
+
+function titleKeywords(title) {
+  return String(title || '')
+    .replace(/[^a-zA-Z0-9\s-]/g, ' ')
+    .split(/\s+/)
+    .filter((word) => word.length > 3 && !/^(the|and|for|with|from|into|over|under|about|between|their|this|that)$/i.test(word))
+    .slice(0, 4)
+    .join(' ');
+}
+
+export function composeMockLiteratureReview(items, prompt = '') {
+  const goal = clean(prompt) || 'the related work';
+  const sentences = [];
+  sentences.push(`A body of prior work has examined ${goal}, with each study contributing a distinct perspective (${items.map((item) => `\\citep{${item.citekey}}`).join(', ')}).`);
+  items.forEach((item, index) => {
+    const topic = titleKeywords(item.title) || 'the central problem';
+    const connector = index === items.length - 1 ? 'Finally' : index === 0 ? 'In particular' : 'Additionally';
+    sentences.push(`${connector}, ${authorLabel(item)} (${item.year || 'n.d.'}) investigated ${topic} and reported findings that bear directly on the questions addressed here (\\citep{${item.citekey}}).`);
+  });
+  sentences.push(`Taken together, these studies motivate the present work, which builds on their evidence while addressing the gaps they leave open.`);
+  return {
+    draft: sentences.join(' '),
+    note: 'Mock review is generated deterministically from bibliographic metadata (authors, year, title keywords). For substantive synthesis, run the same request with a configured external Agent.',
+  };
+}
+
+function buildBibliography(items) {
+  return items.map((item, index) => {
+    const parts = [
+      `${index + 1}. ${authorLabel(item)} (${item.year || 'n.d.'}).`,
+      item.title ? ` ${item.title}.` : '',
+      item.venue ? ` ${item.venue}.` : '',
+      ` [citekey: ${item.citekey}]`,
+    ];
+    if (item.abstract) parts.push(` Abstract: ${String(item.abstract).slice(0, 400)}`);
+    return parts.join('');
+  }).join('\n');
+}
+
+function buildExternalPrompt(bibliography, prompt) {
+  return `You are writing a literature review paragraph for an academic paper. Use only the references supplied below. Cite each relevant reference at least once with \\citep{citekey}. Write 3–6 sentences that synthesize the literature into coherent themes rather than listing entries one by one. Return exactly one suggestion that replaces the entire text ${SENTINEL} with the review paragraph, keeping every citekey that you actually use inside \\citep{...}.
+
+Author instruction:
+${clean(prompt) || 'Synthesize the supplied references into one review paragraph.'}
+
+References:
+${bibliography}`;
+}
+
+export async function generateLiteratureReview(workspaceRoot, input = {}, options = {}) {
+  const citekeys = Array.isArray(input.citekeys) ? input.citekeys.filter((key) => typeof key === 'string' && key.trim()) : [];
+  if (!citekeys.length) throw problem('Select at least one reference');
+  if (citekeys.length > MAX_CITEKEYS) throw problem(`Select at most ${MAX_CITEKEYS} references`);
+  if (new Set(citekeys).size !== citekeys.length) throw problem('citekeys must not contain duplicates');
+  const state = await loadReferenceState(workspaceRoot);
+  const items = citekeys.map((key) => state.items.find((item) => item.citekey === key)).filter(Boolean);
+  const missing = citekeys.filter((key) => !items.some((item) => item.citekey === key));
+  if (missing.length) throw problem(`References not found in the library: ${missing.join(', ')}`, 404);
+  const prompt = clean(input.prompt);
+  const provider = options.provider || 'mock';
+  const bibliography = buildBibliography(items);
+  const startedAt = now();
+  const run = await createAgentRun(workspaceRoot, {
+    provider, operation: 'literature-review', status: provider === 'mock' ? 'queued' : 'running',
+    prompt: prompt || 'Synthesize the selected references into a review paragraph.',
+    input: JSON.stringify({ citekeys, characters: bibliography.length }), output: '', error: '', startedAt, finishedAt: '',
+  });
+  try {
+    let draft;
+    let note = '';
+    if (provider === 'mock') {
+      const composed = composeMockLiteratureReview(items, prompt);
+      draft = composed.draft;
+      note = composed.note;
+    } else {
+      const result = await runWritingAgent(provider, {
+        content: SENTINEL,
+        prompt: buildExternalPrompt(bibliography, prompt),
+        resourceContext: '', resourceIds: [],
+      }, { workspaceRoot, commands: options.commands || {}, signal: options.signal });
+      const proposal = result.suggestions?.find((item) => item.originalText === SENTINEL) || result.suggestions?.[0];
+      if (!proposal?.suggestedText?.trim()) throw problem('Agent did not return a review paragraph', 502);
+      draft = proposal.suggestedText;
+    }
+    const finishedAt = now();
+    await updateAgentRun(workspaceRoot, run.id, {
+      status: 'complete', output: JSON.stringify({ summary: draft.slice(0, 200), characters: draft.length }), finishedAt,
+    });
+    return {
+      runId: run.id, provider, draft, note, citekeys: items.map((item) => item.citekey),
+      bibliography: items.map((item) => ({ citekey: item.citekey, title: item.title, authors: item.authors, year: item.year })),
+    };
+  } catch (error) {
+    await updateAgentRun(workspaceRoot, run.id, { status: 'failed', error: String(error?.message || 'Literature review failed').slice(0, 4000), finishedAt: now() });
+    throw error;
+  }
+}