papilot 0.7.0 → 0.8.0

package/src/shared.ts

@@ -1,4 +1,5 @@
 import type { GroupInstructions, NoteGroup } from './note-groups.ts';
+import type { SkillIcon } from './skill-icons.ts';
 export type TaskStatus = 'idle' | 'queued' | 'running' | 'waiting_input' | 'building' | 'reviewing' | 'interrupted' | 'failed' | 'uncertain' | 'deleting';
 export interface Project { id: string; name: string; path: string; createdAt: number }
 export const MAX_ATTACHMENTS = 10;
@@ -6,7 +7,9 @@ export const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 export const MAX_ATTACHMENT_TOTAL = 100 * 1024 * 1024;
 export interface Attachment { id: string; projectId: string; name: string; size: number; mime: string }
+export type UpdateChannel = 'stable' | 'dev';
 export interface UpdateStatus {
+  channel?: UpdateChannel;
   currentVersion: string; latestVersion: string | null;
   phase: 'idle' | 'checking' | 'available' | 'installing' | 'waiting' | 'restarting' | 'updated' | 'failed';
   checkedAt: number | null; error: string | null; canUpdate: boolean;
@@ -17,19 +20,36 @@ export interface UpdateStatus {
 export interface ReviewSummary { state: string; round: number | null; counts: Record<string, number>; unsent?: number; comments?: number; files?: string[]; next?: string; job?: { phase: string; status: string; error?: string; details?: string[] } | null }
 export interface PendingReview { route: string; body: Record<string, unknown>; previousStatus: TaskStatus }
 export interface Task {
+  mode?: 'edit' | 'review';
+  aiReview?: { key: string; notes?: number; revision?: number };
   // New tasks keep acceptance isolated until the author chooses a destination.
   deferred?: boolean;
   delivery?: { mode: 'workspace' | 'branch'; accepted: string; branch?: string; commit?: string; pending?: boolean } | null;
   id: string; projectId: string; name: string; title: string; instructions: string;
   titleSource?: 'prompt' | 'generated' | 'manual'; titleRevision?: number; titleGeneration?: 'pending' | 'failed' | null;
   worktree: string; threadId: string | null; turnId: string | null; agent?: AgentId; model: string | null; effort?: string | null; serviceTier?: string;
+  // The agent's thread was started with Papilot's view_pdf tool.
+  viewPdf?: boolean;
   status: TaskStatus; createdAt: number; updatedAt: number; feedbackCursor: number;
   archivedAt?: number | null;
   error: string | null; review: ReviewSummary | null;
   pauseVersion?: number; pendingRunId?: string | null;
   pendingReview?: PendingReview | null;
   // The task's last commit from its review, and the accepted text it included.
-  committed?: { hash: string; accepted: string; at: number } | null;
+  committed?: { hash: string; accepted: string; at: number; pushed?: boolean } | null;
+}
+// A task the author is through with, which Papilot archives once they leave
+// it: every change of its last result is decided, no comment or rejection
+// waits to go back to the agent, and what was accepted has left the task
+// (applied or committed; older tasks accept straight into the working
+// directory). An answer without manuscript changes is finished too.
+export function taskFinished(task: Task) {
+  const review = task.review;
+  if (task.status !== 'reviewing' || !review || task.pendingReview || task.delivery?.pending || review.counts?.pending || review.state === 'build_failed') return false;
+  const unsent = review.unsent ?? ['accepted', 'rejected', 'commented'].reduce((count, kind) => count + (review.counts?.[kind] || 0), 0);
+  if ((review.comments ?? unsent) > 0 || (unsent > 0 && !review.counts?.accepted)) return false;
+  if (review.round === null) return true;
+  return review.state === 'done' && (!task.deferred || review.files?.length === 0);
 }
 // reviewRound is 0 while awaiting a result, null when no changes were produced,
 // or the published round. Older runs omit it.
@@ -42,21 +62,32 @@ export interface NoteAnchor { sources: { file: string; lines: [number, number] }
 export interface NoteSummary { group?: NoteGroup; where: string; quote: string; comment: string; id?: string; anchor?: NoteAnchor }
 export interface NoteChange { round: number; stop: number; units: string[]; state: 'pending' | 'accepted' | 'rejected' | 'commented' | 'mixed'; match: 'source' | 'quote' }
 export interface NoteResult { key: string; itemId: string; index: number; note: NoteSummary; round: number | null; state: 'waiting' | 'unmatched' | 'matched'; changes: NoteChange[] }
-export interface MessageMeta { attachments?: Attachment[]; skill?: { id: string; name: string }; notes?: NoteSummary[]; groupInstructions?: GroupInstructions; feedback?: FeedbackSummary; sendsFeedback?: boolean; build?: BuildFailure; author?: Author }
+export interface MessageMeta { attachments?: Attachment[]; skill?: { id: string; name: string; icon?: SkillIcon }; notes?: NoteSummary[]; groupInstructions?: GroupInstructions; feedback?: FeedbackSummary; sendsFeedback?: boolean; build?: BuildFailure; author?: Author }
 // Who wrote a message or note; none means the owner.
 export interface Author { id: string; name: string }
 // A failed review build as the engine reports it; log is the compiler log's path.
 export interface BuildFailure { error: string; details: string[]; log?: string }
 export interface FeedbackSummary { round: number | null; accepted: number; rejected: number; undone: number; comments: { where: string; text: string }[]; buildError?: boolean }
-export interface Skill { id: string; name: string; description: string; hint: string; source: 'builtin' | 'user' | 'paper' }
+export interface Skill { output?: 'annotations'; id: string; name: string; description: string; hint: string; icon?: SkillIcon; source: 'builtin' | 'user' | 'paper' }
 export interface PendingRequest { id: string; taskId: string; method: string; params: Record<string, any>; createdAt: number }
-export type AgentId = 'codex' | 'claude' | 'antigravity';
+export type AgentId = 'codex' | 'claude' | 'antigravity' | 'kimi' | 'cursor' | 'opencode' | 'qwen' | 'glm' | 'deepseek';
+// Every agent Papilot can drive, in menu order. Only the ones found on the host are offered.
+export const AGENT_IDS: AgentId[] = ['codex', 'claude', 'cursor', 'antigravity', 'kimi', 'glm', 'deepseek', 'qwen', 'opencode'];
+export const AGENT_NAMES: Record<AgentId, string> = { codex: 'Codex', claude: 'Claude', cursor: 'Cursor', antigravity: 'Antigravity', kimi: 'Kimi', glm: 'GLM', deepseek: 'DeepSeek', qwen: 'Qwen', opencode: 'OpenCode' };
+export const isAgentId = (value: unknown): value is AgentId => AGENT_IDS.includes(value as AgentId);
 export interface AgentModel { id: string; name: string; isDefault: boolean; efforts: string[]; defaultEffort: string | null; fastMode?: { serviceTier: string; description: string } }
 // The account's included usage: rolling windows (minutes long, reset time in ms) and credits.
 export interface UsageWindow { usedPercent: number; minutes: number | null; resetsAt: number | null }
 export interface Usage { plan: string | null; windows: UsageWindow[]; credits: { unlimited: boolean; balance: number | null } | null; reached: boolean }
-export interface RuntimeStatus { connected: boolean; authenticated: boolean; account: string | null; error: string | null; models: AgentModel[]; usage?: Usage | null }
+// installed is false when the agent was not found on the host (no CLI, SDK
+// credentials or key); such agents are not offered. Older servers omit it.
+export interface RuntimeStatus { connected: boolean; authenticated: boolean; account: string | null; error: string | null; models: AgentModel[]; usage?: Usage | null; installed?: boolean }
 export interface DiagnosticCheck { id: string; ok: boolean; severity: 'error' | 'warn' | 'info'; detail: string; fix: string | null }
+export interface LatexInstallation {
+  distribution: 'MacTeX' | 'BasicTeX' | 'TeX Live' | 'MiKTeX' | null;
+  version: string | null;
+  path: string;
+}
 export interface DiagnosticReport {
   version: string; checkedAt: number; platform: string; arch: string; node: string;
   ok: boolean; checks: DiagnosticCheck[];
@@ -84,11 +115,51 @@ export interface GitWorktree {
 }
 export interface GitGraphCommit { hash: string; parents: string[]; subject: string; author: string; date: number; refs: string[] }
 export interface GitOverview { worktrees: GitWorktree[]; commits: GitGraphCommit[]; truncated: boolean }
-export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean }
-export interface Annotation { group?: NoteGroup; id: string; projectId: string; key: string; page: number; rect: [number, number, number, number]; rects?: [number, number, number, number][]; comment: string; quote: string; source: { file: string; lines: [number, number]; excerpt?: string } | null; createdAt: number; taskId?: string; author?: Author; deletedAt?: number }
+export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean; problems?: BuildProblemCounts }
+// What the last finished build reported. Errors stop the build; warnings are
+// mistakes in the PDF (?? and missing citations); minor problems are
+// typesetting (overfull lines) and package remarks, listed but never counted.
+export type BuildProblemKind = 'error' | 'missing-file' | 'reference' | 'citation' | 'label' | 'glyph' | 'overfull' | 'other';
+export interface BuildProblem {
+  kind: BuildProblemKind; severity: 'error' | 'warning' | 'minor'; message: string;
+  key?: string; file?: string; line?: number; end?: number; amount?: number; count?: number;
+  page?: number; rect?: [number, number, number, number];
+}
+export interface BuildProblemCounts { errors: number; warnings: number; minor: number }
+// A label defined twice is listed at each definition but counts as one problem.
+export function countProblems(problems: Pick<BuildProblem, 'severity' | 'kind' | 'key'>[]): BuildProblemCounts {
+  const counts = { errors: 0, warnings: 0, minor: 0 }, labels = new Set<string>();
+  for (const problem of problems) {
+    if (problem.kind === 'label' && problem.key) { if (labels.has(problem.key)) continue; labels.add(problem.key); }
+    counts[problem.severity === 'error' ? 'errors' : problem.severity === 'warning' ? 'warnings' : 'minor']++;
+  }
+  return counts;
+}
+// `key` names the PDF whose pages the locations refer to.
+export interface ManuscriptProblems { status: ManuscriptBuild['status']; key?: string; problems: BuildProblem[]; log: boolean }
+export interface Annotation { aiReview?: { taskId: string; agent: AgentId; sourceId?: string; copiedTo?: string }; group?: NoteGroup; id: string; projectId: string; key: string; page: number; rect: [number, number, number, number]; rects?: [number, number, number, number][]; comment: string; quote: string; source: { file: string; lines: [number, number]; excerpt?: string } | null; createdAt: number; taskId?: string; author?: Author; deletedAt?: number }
+// Review findings stay with their task; only explicit copies belong to the manuscript.
+export const isTaskReviewNote = (note: Annotation) => Boolean(note.aiReview && !note.aiReview.sourceId);
 export interface Manuscript { git: GitStatus; build: ManuscriptBuild; annotations: Annotation[] }
 export interface PaperImport {
   id: string; path: string; name: string; copied: boolean; candidates: string[]; main: string; engine: string;
   phase: 'choose' | 'building' | 'failed' | 'ready' | 'repairing';
   error?: string; summary?: string; versioned?: boolean;
 }
+// The paper's bibliography as the References panel reads it: the review
+// engine's report of every entry, with online checks and the entries the
+// author checked by hand.
+export interface ReferenceCitation { file: string; line: number; section: string | null }
+export interface ReferenceRecord { source: 'doi' | 'crossref' | 'arxiv' | 'dblp'; title: string; authors: string[]; year: number | null; venue: string | null; doi: string | null; url: string }
+export interface ReferenceCheck {
+  status: 'verified' | 'mismatch' | 'unverified' | 'failed' | 'skipped';
+  record?: ReferenceRecord; via: 'doi' | 'arxiv' | 'title' | null;
+  differences: { field: 'title' | 'author' | 'year' | 'doi' | 'arxiv'; bib: string; record: string; minor?: boolean }[];
+  reason?: 'doi-not-found' | 'arxiv-not-found' | 'no-match' | 'nothing-to-check'; unavailable: string[]; checked: number;
+}
+export interface BibliographyEntry { id: string; file: string; key: string; type: string; fields: { name: string; value: string; resolved?: string }[]; lines: [number, number]; cited: ReferenceCitation[]; error?: string }
+export interface BibliographyReport {
+  bibs: string[]; absent: string[]; entries: BibliographyEntry[];
+  missing: (ReferenceCitation & { key: string })[]; duplicates: string[][]; similar: { ids: string[]; by: 'doi' | 'title' }[]; all_cited: boolean;
+  checks: Record<string, ReferenceCheck>; pending: number; confirmed: Record<string, number>;
+}

package/src/skill-icons.ts

@@ -0,0 +1,18 @@
+// Shared by the file parser and every surface that displays a skill.
+export const SKILL_ICONS = [
+  { id: 'spark', label: 'Sparkles' }, { id: 'pen', label: 'Pen' },
+  { id: 'spellcheck', label: 'Spelling' }, { id: 'compress', label: 'Shorten' },
+  { id: 'sigma', label: 'Math' }, { id: 'checklist', label: 'Checklist' },
+  { id: 'notes', label: 'Comments' }, { id: 'book', label: 'Book' },
+  { id: 'search', label: 'Search' }, { id: 'code', label: 'Code' },
+  { id: 'tool', label: 'Tools' }, { id: 'chart', label: 'Chart' },
+  { id: 'globe', label: 'Globe' }, { id: 'lightbulb', label: 'Idea' },
+  { id: 'link', label: 'Link' }, { id: 'branch', label: 'Branch' },
+] as const;
+export type SkillIcon = typeof SKILL_ICONS[number]['id'];
+export const isSkillIcon = (value: unknown): value is SkillIcon => SKILL_ICONS.some(icon => icon.id === value);
+const defaults: Record<string, SkillIcon> = {
+  polish: 'spark', proofread: 'spellcheck', shorten: 'compress', 'check-math': 'sigma',
+  consistency: 'checklist', 'latex-warnings': 'tool', 'reviewer-response': 'notes', 'ai-review': 'notes',
+};
+export const resolveSkillIcon = (skill: { id: string; icon?: string }): SkillIcon => isSkillIcon(skill.icon) ? skill.icon : Object.hasOwn(defaults, skill.id) ? defaults[skill.id] : 'spark';

package/src/skill-metadata.ts

@@ -0,0 +1,45 @@
+// Keep a skill's source intact when editing one field in the visual editor.
+// This is the same small, single-line front-matter format used by the loader.
+function parts(content: string) {
+  const bom = content.startsWith('\uFEFF') ? '\uFEFF' : '';
+  const source = content.slice(bom.length);
+  const header = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(source);
+  return { bom, source, header, newline: source.includes('\r\n') ? '\r\n' : '\n' };
+}
+export function skillMetadata(content: string): Record<string, string> {
+  const { header } = parts(content), fields: Record<string, string> = {};
+  for (const line of header?.[1].split(/\r?\n/) || []) {
+    const field = /^([A-Za-z-]+):\s*(.*)$/.exec(line);
+    if (field) {
+      const value = field[2].trim();
+      let decoded = value.replace(/^(['"])(.*)\1$/, '$2');
+      if (value.startsWith('"') && value.endsWith('"')) {
+        try { decoded = JSON.parse(value); } catch { /* Preserve legacy quoted values. */ }
+      }
+      fields[field[1].toLowerCase()] = decoded;
+    }
+  }
+  return fields;
+}
+export const skillInstructions = (content: string) => {
+  const { source, header } = parts(content);
+  return source.slice(header?.[0].length || 0);
+};
+export function setSkillMetadata(content: string, field: 'name' | 'description' | 'icon', value: string) {
+  const { bom, source, header, newline } = parts(content);
+  const clean = value.replace(/[\r\n]/g, ' ');
+  const line = `${field}: ${field === 'icon' ? clean : JSON.stringify(clean)}`;
+  if (!header) return `${bom}---${newline}${line}${newline}---${newline}${newline}${source}`;
+  const rows = header[1].split(/\r?\n/);
+  const matches = new RegExp(`^${field}:`, 'i');
+  // Remove duplicate definitions so the visual value cannot be overridden later.
+  const index = rows.findIndex(row => matches.test(row));
+  const next = rows.filter(row => !matches.test(row));
+  next.splice(index < 0 ? next.length : index, 0, line);
+  const closingNewline = header[0].endsWith('\n') ? newline : '';
+  return `${bom}---${newline}${next.join(newline)}${newline}---${closingNewline}${source.slice(header[0].length)}`;
+}
+export function setSkillInstructions(content: string, body: string) {
+  const { bom, source, header, newline } = parts(content);
+  return header ? `${bom}${header[0]}${header[0].endsWith('\n') ? '' : newline}${body}` : `${bom}${body}`;
+}