openwriter 0.40.1 → 0.40.3

package/dist/server/documents.js

@@ -913,6 +913,19 @@ export async function deleteDocument(filename) {
         throw new Error('Cannot delete the only document');
     }
     const isDeletingActive = targetPath === getFilePath();
+    // Capture the sidebar's flat order BEFORE the file is trashed, so a
+    // delete-of-the-active-doc can land the switch on the doc ADJACENT to the one
+    // removed (least-jarring — the view barely moves). The prior behavior switched
+    // to the globally newest-by-mtime doc, which flung the editor + filetree across
+    // the workspace to an unrelated doc. Only needed when deleting the active doc.
+    const orderedBefore = isDeletingActive
+        ? (() => { try {
+            return listDocuments().map((d) => d.filename);
+        }
+        catch {
+            return [];
+        } })()
+        : [];
     // Read docId BEFORE deleting the file so we can retire its overlay sidecar
     // in lockstep. The sidecar's lifecycle is bound to the docId's existence in
     // the workspace; delete retires the docId, archive does not.
@@ -933,16 +946,50 @@ export async function deleteDocument(filename) {
     if (docIdToRetire)
         deleteOverlay(docIdToRetire);
     if (isDeletingActive) {
-        const remaining = readdirSync(getDataDir())
-            .filter((f) => f.endsWith('.md'))
-            .map((f) => ({ name: f, path: join(getDataDir(), f), mtime: statSync(join(getDataDir(), f)).mtimeMs }))
-            .sort((a, b) => b.mtime - a.mtime);
-        if (remaining.length > 0) {
-            const next = remaining[0];
-            const raw = readFileSync(next.path, 'utf-8');
+        // Prefer the doc adjacent to the deleted one in sidebar order — previous
+        // sibling first, then next. Falls back to newest-by-mtime only if the order
+        // lookup comes up empty (e.g. manifest missing), preserving old behavior.
+        let nextName = null;
+        const idx = orderedBefore.indexOf(filename);
+        if (idx >= 0) {
+            for (let i = idx - 1; i >= 0; i--) {
+                if (orderedBefore[i] !== filename) {
+                    nextName = orderedBefore[i];
+                    break;
+                }
+            }
+            if (!nextName) {
+                for (let i = idx + 1; i < orderedBefore.length; i++) {
+                    if (orderedBefore[i] !== filename) {
+                        nextName = orderedBefore[i];
+                        break;
+                    }
+                }
+            }
+        }
+        let nextPath = null;
+        if (nextName) {
+            const p = resolveDocPath(nextName);
+            if (existsSync(p))
+                nextPath = p;
+        }
+        if (!nextPath) {
+            const remaining = readdirSync(getDataDir())
+                .filter((f) => f.endsWith('.md'))
+                .map((f) => ({ name: f, path: join(getDataDir(), f), mtime: statSync(join(getDataDir(), f)).mtimeMs }))
+                .sort((a, b) => b.mtime - a.mtime);
+            if (remaining.length > 0) {
+                nextName = remaining[0].name;
+                nextPath = remaining[0].path;
+            }
+        }
+        if (nextPath && nextName) {
+            const nextBase = nextPath.split(/[/\\]/).pop() || nextName;
+            const raw = readFileSync(nextPath, 'utf-8');
             const parsed = markdownToTiptap(raw);
-            setActiveDocument(parsed.document, parsed.title, next.path, next.name.startsWith(TEMP_PREFIX), new Date(next.mtime), parsed.metadata, undefined);
-            return { switched: true, newDoc: { document: getDocument(), title: getTitle(), filename: next.name } };
+            const mtime = statSync(nextPath).mtimeMs;
+            setActiveDocument(parsed.document, parsed.title, nextPath, nextBase.startsWith(TEMP_PREFIX), new Date(mtime), parsed.metadata, undefined);
+            return { switched: true, newDoc: { document: getDocument(), title: getTitle(), filename: nextName } };
         }
     }
     return { switched: false };

package/dist/server/git-sync.js

@@ -0,0 +1,273 @@
+/**
+ * Git sync module: all git/gh CLI interactions for GitHub sync.
+ * Uses child_process.execFile with shell:true (required on Windows).
+ */
+import { execFile } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getDataDir, readConfig, saveConfig } from './helpers.js';
+import { save, cancelDebouncedSave } from './state.js';
+const GITIGNORE_CONTENT = `config.json\n.versions/\n`;
+const NETWORK_TIMEOUT = 30000;
+let currentSyncState = 'unconfigured';
+let lastError;
+function exec(cmd, args, cwd, timeout = 10000) {
+    // Quote args with spaces so shell: true doesn't split them
+    const safeArgs = args.map(a => a.includes(' ') ? `"${a}"` : a);
+    return new Promise((resolve, reject) => {
+        execFile(cmd, safeArgs, { cwd, shell: true, timeout }, (err, stdout, stderr) => {
+            if (err)
+                reject(new Error(stderr?.trim() || err.message));
+            else
+                resolve(stdout.trim());
+        });
+    });
+}
+export async function isGitInstalled() {
+    try {
+        await exec('git', ['--version'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhInstalled() {
+    try {
+        await exec('gh', ['--version'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhAuthenticated() {
+    try {
+        await exec('gh', ['auth', 'status'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isGitRepo() {
+    return existsSync(join(getDataDir(), '.git'));
+}
+function ensureGitignore() {
+    const gitignorePath = join(getDataDir(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, GITIGNORE_CONTENT, 'utf-8');
+    }
+}
+/** Count files that have changed since last commit (or all files if no commits yet). */
+async function countPendingFiles() {
+    if (!isGitRepo())
+        return 0;
+    try {
+        // Check for any changes (staged + unstaged + untracked)
+        const status = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (!status)
+            return 0;
+        return status.split('\n').filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Return the list of pending files with their status. */
+export async function getPendingFiles() {
+    if (!isGitRepo())
+        return [];
+    try {
+        const output = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (!output)
+            return [];
+        return output.split('\n').filter(Boolean).map(line => {
+            const code = line.substring(0, 2);
+            const file = line.substring(3);
+            let status = 'modified';
+            if (code.includes('?') || code.includes('A'))
+                status = 'added';
+            else if (code.includes('D'))
+                status = 'deleted';
+            else if (code.includes('R'))
+                status = 'renamed';
+            return { status, file };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function getSyncStatus() {
+    const config = readConfig();
+    if (!config.gitConfigured || !isGitRepo()) {
+        return { state: 'unconfigured' };
+    }
+    if (currentSyncState === 'syncing') {
+        return { state: 'syncing' };
+    }
+    if (currentSyncState === 'error' && lastError) {
+        return { state: 'error', error: lastError, lastSyncTime: config.lastSyncTime };
+    }
+    const pending = await countPendingFiles();
+    return {
+        state: pending > 0 ? 'pending' : 'synced',
+        pendingFiles: pending,
+        lastSyncTime: config.lastSyncTime,
+    };
+}
+export async function getCapabilities() {
+    const [git, gh] = await Promise.all([isGitInstalled(), isGhInstalled()]);
+    let ghAuth = false;
+    if (gh)
+        ghAuth = await isGhAuthenticated();
+    let remoteUrl;
+    if (isGitRepo()) {
+        try {
+            remoteUrl = await exec('git', ['remote', 'get-url', 'origin'], getDataDir());
+        }
+        catch { /* no remote */ }
+    }
+    return {
+        gitInstalled: git,
+        ghInstalled: gh,
+        ghAuthenticated: ghAuth,
+        existingRepo: isGitRepo(),
+        remoteUrl,
+    };
+}
+async function initRepo() {
+    if (!isGitRepo()) {
+        await exec('git', ['init'], getDataDir());
+    }
+    ensureGitignore();
+    // Ensure git user is configured (required for commits)
+    try {
+        await exec('git', ['config', 'user.name'], getDataDir());
+    }
+    catch {
+        await exec('git', ['config', 'user.name', 'OpenWriter'], getDataDir());
+    }
+    try {
+        await exec('git', ['config', 'user.email'], getDataDir());
+    }
+    catch {
+        await exec('git', ['config', 'user.email', 'openwriter@local'], getDataDir());
+    }
+}
+async function initialCommit() {
+    await exec('git', ['add', '-A'], getDataDir());
+    // Check if there's anything staged
+    const status = await exec('git', ['status', '--porcelain'], getDataDir());
+    if (!status)
+        return; // Nothing to commit
+    await exec('git', ['commit', '-m', 'Initial sync from OpenWriter'], getDataDir());
+    // Ensure branch is named 'main'
+    await exec('git', ['branch', '-M', 'main'], getDataDir());
+}
+export async function setupWithGh(repoName, isPrivate) {
+    await initRepo();
+    await initialCommit();
+    const visibility = isPrivate ? '--private' : '--public';
+    // Create repo without --push, then push separately for better error control
+    await exec('gh', ['repo', 'create', repoName, visibility, '--source=.', '--remote=origin'], getDataDir(), NETWORK_TIMEOUT);
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        repoName,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function setupWithPat(pat, repoName, isPrivate) {
+    // Create repo via GitHub REST API
+    const res = await fetch('https://api.github.com/user/repos', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${pat}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github+json',
+        },
+        body: JSON.stringify({ name: repoName, private: isPrivate, auto_init: false }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.message || `GitHub API error: ${res.status}`);
+    }
+    const repo = await res.json();
+    const remoteUrl = `https://${pat}@github.com/${repo.full_name}.git`;
+    await initRepo();
+    await initialCommit();
+    // Set remote
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], getDataDir());
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', remoteUrl], getDataDir());
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        repoName,
+        gitRemote: repo.html_url,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function connectExisting(remoteUrl, pat) {
+    await initRepo();
+    await initialCommit();
+    // Embed PAT in URL if provided
+    let finalUrl = remoteUrl;
+    if (pat && remoteUrl.startsWith('https://')) {
+        finalUrl = remoteUrl.replace('https://', `https://${pat}@`);
+    }
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], getDataDir());
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', finalUrl], getDataDir());
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        gitRemote: remoteUrl,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function pushSync(onStatus) {
+    currentSyncState = 'syncing';
+    lastError = undefined;
+    onStatus({ state: 'syncing' });
+    try {
+        // Flush current document to disk first (cancel debounce to ensure immediate write)
+        cancelDebouncedSave();
+        save();
+        ensureGitignore();
+        await exec('git', ['add', '-A'], getDataDir());
+        // Check if there's anything to commit
+        const status = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (status) {
+            const timestamp = new Date().toLocaleString('en-US', {
+                month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit',
+            });
+            await exec('git', ['commit', '-m', `Sync: ${timestamp}`], getDataDir());
+        }
+        await exec('git', ['push'], getDataDir(), NETWORK_TIMEOUT);
+        const now = new Date().toISOString();
+        saveConfig({ lastSyncTime: now });
+        currentSyncState = 'synced';
+        const result = { state: 'synced', lastSyncTime: now, pendingFiles: 0 };
+        onStatus(result);
+        return result;
+    }
+    catch (err) {
+        currentSyncState = 'error';
+        lastError = err.message;
+        const result = { state: 'error', error: err.message };
+        onStatus(result);
+        return result;
+    }
+}

package/dist/server/marks.js

@@ -0,0 +1,182 @@
+/**
+ * Agent Marks: sidecar JSON storage for inline user feedback.
+ * Each document gets a sidecar file at DATA_DIR/_marks/{filename}.json.
+ */
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, renameSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { getDataDir, ensureDataDir } from './helpers.js';
+function getMarksDir() { return join(getDataDir(), '_marks'); }
+function ensureMarksDir() {
+    ensureDataDir();
+    if (!existsSync(getMarksDir()))
+        mkdirSync(getMarksDir(), { recursive: true });
+}
+function markFilePath(filename) {
+    // Sanitize: replace path separators to avoid nested paths
+    const safe = filename.replace(/[/\\]/g, '_');
+    return join(getMarksDir(), `${safe}.json`);
+}
+function readMarkFile(filename) {
+    const path = markFilePath(filename);
+    if (!existsSync(path))
+        return { marks: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { marks: [] };
+    }
+}
+function writeMarkFile(filename, data) {
+    ensureMarksDir();
+    const path = markFilePath(filename);
+    if (data.marks.length === 0) {
+        // Clean up empty sidecar files
+        if (existsSync(path))
+            unlinkSync(path);
+        return;
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2));
+}
+export function addMark(filename, text, note, nodeId, nodeIds) {
+    const data = readMarkFile(filename);
+    const mark = {
+        id: randomUUID().slice(0, 8),
+        text,
+        note,
+        nodeId,
+        ...(nodeIds && nodeIds.length > 1 ? { nodeIds } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    data.marks.push(mark);
+    writeMarkFile(filename, data);
+    return mark;
+}
+export function getMarks(filename) {
+    if (filename) {
+        const data = readMarkFile(filename);
+        if (data.marks.length === 0)
+            return {};
+        return { [filename]: data.marks };
+    }
+    // All docs: scan _marks directory
+    ensureMarksDir();
+    const result = {};
+    try {
+        const files = readdirSync(getMarksDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+            // Read raw to avoid filename roundtrip issues
+            const path = join(getMarksDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                if (data.marks.length > 0)
+                    result[docFilename] = data.marks;
+            }
+            catch { /* skip corrupt files */ }
+        }
+    }
+    catch { /* dir doesn't exist yet */ }
+    return result;
+}
+export function getMarkCount(filename) {
+    return readMarkFile(filename).marks.length;
+}
+/** Count marks across all documents, optionally excluding one filename. */
+export function getGlobalMarkSummary(excludeFilename) {
+    ensureMarksDir();
+    let totalMarks = 0;
+    let docCount = 0;
+    try {
+        const files = readdirSync(getMarksDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            if (excludeFilename) {
+                const safe = excludeFilename.replace(/[/\\]/g, '_');
+                if (file === `${safe}.json`)
+                    continue;
+            }
+            const path = join(getMarksDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                if (data.marks.length > 0) {
+                    totalMarks += data.marks.length;
+                    docCount++;
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return { totalMarks, docCount };
+}
+export function editMark(filename, id, note) {
+    const data = readMarkFile(filename);
+    const mark = data.marks.find((m) => m.id === id);
+    if (!mark)
+        return null;
+    mark.note = note;
+    writeMarkFile(filename, data);
+    return mark;
+}
+export function resolveMarks(ids) {
+    const idSet = new Set(ids);
+    const resolved = [];
+    ensureMarksDir();
+    try {
+        const files = readdirSync(getMarksDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(getMarksDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                const before = data.marks.length;
+                data.marks = data.marks.filter((m) => {
+                    if (idSet.has(m.id)) {
+                        resolved.push(m.id);
+                        return false;
+                    }
+                    return true;
+                });
+                if (data.marks.length !== before) {
+                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+                    writeMarkFile(docFilename, data);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return resolved;
+}
+export function pruneStaleMarks(filename, validNodeIds) {
+    const data = readMarkFile(filename);
+    if (data.marks.length === 0)
+        return 0;
+    const validSet = new Set(validNodeIds);
+    const before = data.marks.length;
+    data.marks = data.marks.filter((m) => {
+        // Multi-node mark: keep if ANY nodeId is still valid
+        if (m.nodeIds && m.nodeIds.length > 0) {
+            return m.nodeIds.some((id) => validSet.has(id));
+        }
+        return validSet.has(m.nodeId);
+    });
+    const pruned = before - data.marks.length;
+    if (pruned > 0)
+        writeMarkFile(filename, data);
+    return pruned;
+}
+/** Rename a mark sidecar file when a document is renamed. */
+export function renameMark(oldFilename, newFilename) {
+    const oldPath = markFilePath(oldFilename);
+    if (!existsSync(oldPath))
+        return;
+    const newPath = markFilePath(newFilename);
+    renameSync(oldPath, newPath);
+}