@portablecore/notes-sync 0.1.0

package/dist/apple-notes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Apple Notes Access
+ *
+ * Reads notes via AppleScript (osascript) since the SQLite database
+ * is sandboxed and uses a complex protobuf format.
+ * Writes via AppleScript or notes:// URL scheme.
+ *
+ * macOS only. Requires the Notes app to be present.
+ */
+export interface AppleNote {
+    id: string;
+    title: string;
+    content: string;
+    folder: string;
+    createdAt: string;
+    modifiedAt: string;
+}
+export interface AppleNoteCompact {
+    id: string;
+    title: string;
+    folder: string;
+    modifiedAt: string;
+    createdAt: string;
+    contentLength: number;
+    preview: string;
+}
+export declare function isAppleNotesAvailable(): boolean;
+/**
+ * Get all notes with metadata (no body, for listing).
+ */
+export declare function getAllNotesCompact(): AppleNoteCompact[];
+/**
+ * Get full content of a single note by ID or title.
+ */
+export declare function getNote(identifier: string): AppleNote | null;
+/**
+ * Search notes by keyword (title and body).
+ */
+export declare function searchNotes(query: string, limit?: number): AppleNoteCompact[];
+/**
+ * Get recently modified notes.
+ */
+export declare function getRecentNotes(limit?: number): AppleNoteCompact[];
+/**
+ * List all folders.
+ */
+export declare function listFolders(): Array<{
+    name: string;
+    noteCount: number;
+}>;
+/**
+ * Get notes in a specific folder.
+ */
+export declare function getNotesByFolder(folder: string, limit?: number): AppleNoteCompact[];
+/**
+ * Create a new note in Apple Notes.
+ */
+export declare function createNote(title: string, content: string, folder?: string): Promise<string>;

package/dist/apple-notes.js

@@ -0,0 +1,195 @@
+/**
+ * Apple Notes Access
+ *
+ * Reads notes via AppleScript (osascript) since the SQLite database
+ * is sandboxed and uses a complex protobuf format.
+ * Writes via AppleScript or notes:// URL scheme.
+ *
+ * macOS only. Requires the Notes app to be present.
+ */
+import { execFileSync, execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ---------------------------------------------------------------------------
+// Availability
+// ---------------------------------------------------------------------------
+const NOTES_DB_PATH = join(homedir(), "Library/Group Containers/group.com.apple.notes/NoteStore.sqlite");
+export function isAppleNotesAvailable() {
+    if (process.platform !== "darwin")
+        return false;
+    return existsSync(NOTES_DB_PATH);
+}
+// ---------------------------------------------------------------------------
+// AppleScript helpers
+// ---------------------------------------------------------------------------
+function runOsascript(script) {
+    return execFileSync("osascript", ["-e", script], {
+        encoding: "utf-8",
+        timeout: 30000,
+    }).trim();
+}
+function parseAppleDate(dateStr) {
+    try {
+        const d = new Date(dateStr);
+        return isNaN(d.getTime()) ? dateStr : d.toISOString();
+    }
+    catch {
+        return dateStr;
+    }
+}
+// ---------------------------------------------------------------------------
+// Read operations
+// ---------------------------------------------------------------------------
+/**
+ * Get all notes with metadata (no body, for listing).
+ */
+export function getAllNotesCompact() {
+    const script = `
+    tell application "Notes"
+      set output to ""
+      repeat with n in notes of default account
+        try
+          set noteId to id of n
+          set noteName to name of n
+          try
+            set noteFolder to name of container of n
+          on error
+            set noteFolder to ""
+          end try
+          set noteModDate to (modification date of n) as string
+          set noteCreateDate to (creation date of n) as string
+          set noteBody to plaintext of n
+          set bodyLen to count of noteBody
+          if bodyLen > 200 then
+            set notePreview to text 1 thru 200 of noteBody
+          else
+            set notePreview to noteBody
+          end if
+          set output to output & noteId & "\\t" & noteName & "\\t" & noteFolder & "\\t" & noteModDate & "\\t" & noteCreateDate & "\\t" & bodyLen & "\\t" & notePreview & linefeed
+        end try
+      end repeat
+      return output
+    end tell
+  `;
+    const raw = runOsascript(script);
+    if (!raw)
+        return [];
+    return raw.split("\n").filter(Boolean).map((line) => {
+        const parts = line.split("\t");
+        return {
+            id: parts[0] ?? "",
+            title: parts[1] ?? "(untitled)",
+            folder: parts[2] ?? "",
+            modifiedAt: parseAppleDate(parts[3] ?? ""),
+            createdAt: parseAppleDate(parts[4] ?? ""),
+            contentLength: parseInt(parts[5] ?? "0", 10),
+            preview: parts[6] ?? "",
+        };
+    });
+}
+/**
+ * Get full content of a single note by ID or title.
+ */
+export function getNote(identifier) {
+    const isId = identifier.startsWith("x-coredata://");
+    const matchField = isId ? "id" : "name";
+    const script = `
+    tell application "Notes"
+      try
+        set matchedNote to first note of default account whose ${matchField} is "${identifier.replace(/"/g, '\\"')}"
+        set noteId to id of matchedNote
+        set noteName to name of matchedNote
+        try
+          set noteFolder to name of container of matchedNote
+        on error
+          set noteFolder to ""
+        end try
+        set noteModDate to (modification date of matchedNote) as string
+        set noteCreateDate to (creation date of matchedNote) as string
+        set noteBody to body of matchedNote
+        return noteId & "\\t" & noteName & "\\t" & noteFolder & "\\t" & noteModDate & "\\t" & noteCreateDate & "\\t" & noteBody
+      on error
+        return ""
+      end try
+    end tell
+  `;
+    const raw = runOsascript(script);
+    if (!raw)
+        return null;
+    const parts = raw.split("\t");
+    return {
+        id: parts[0] ?? "",
+        title: parts[1] ?? "(untitled)",
+        folder: parts[2] ?? "",
+        modifiedAt: parseAppleDate(parts[3] ?? ""),
+        createdAt: parseAppleDate(parts[4] ?? ""),
+        content: parts.slice(5).join("\t"),
+    };
+}
+/**
+ * Search notes by keyword (title and body).
+ */
+export function searchNotes(query, limit = 20) {
+    const all = getAllNotesCompact();
+    const lowerQuery = query.toLowerCase();
+    return all
+        .filter((n) => n.title.toLowerCase().includes(lowerQuery) || n.preview.toLowerCase().includes(lowerQuery))
+        .slice(0, limit);
+}
+/**
+ * Get recently modified notes.
+ */
+export function getRecentNotes(limit = 20) {
+    const all = getAllNotesCompact();
+    return all
+        .sort((a, b) => new Date(b.modifiedAt).getTime() - new Date(a.modifiedAt).getTime())
+        .slice(0, limit);
+}
+/**
+ * List all folders.
+ */
+export function listFolders() {
+    const all = getAllNotesCompact();
+    const folderCounts = new Map();
+    for (const note of all) {
+        folderCounts.set(note.folder, (folderCounts.get(note.folder) ?? 0) + 1);
+    }
+    return [...folderCounts.entries()]
+        .map(([name, noteCount]) => ({ name, noteCount }))
+        .sort((a, b) => b.noteCount - a.noteCount);
+}
+/**
+ * Get notes in a specific folder.
+ */
+export function getNotesByFolder(folder, limit = 50) {
+    const all = getAllNotesCompact();
+    return all
+        .filter((n) => n.folder.toLowerCase() === folder.toLowerCase())
+        .slice(0, limit);
+}
+// ---------------------------------------------------------------------------
+// Write operations
+// ---------------------------------------------------------------------------
+/**
+ * Create a new note in Apple Notes.
+ */
+export async function createNote(title, content, folder) {
+    const folderClause = folder
+        ? `in folder "${folder.replace(/"/g, '\\"')}" of default account`
+        : "in default account";
+    const script = `
+    tell application "Notes"
+      set newNote to make new note ${folderClause} with properties {name:"${title.replace(/"/g, '\\"')}", body:"${content.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"}
+      return id of newNote
+    end tell
+  `;
+    return new Promise((resolve, reject) => {
+        execFile("osascript", ["-e", script], { timeout: 15000 }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout.trim());
+        });
+    });
+}

package/dist/bear.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Bear Notes Database Access
+ *
+ * Read-only access to Bear's local SQLite database via better-sqlite3.
+ * Write operations go through Bear's URL scheme (bear://x-callback-url/).
+ *
+ * Bear uses CoreData, so timestamps are seconds since Jan 1, 2001 (not Unix epoch).
+ * The offset is 978307200 seconds.
+ */
+export interface BearNote {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    modifiedAt: string;
+    isPinned: boolean;
+    isArchived: boolean;
+}
+export interface BearNoteCompact {
+    id: string;
+    title: string;
+    createdAt: string;
+    modifiedAt: string;
+    isPinned: boolean;
+    isArchived: boolean;
+    contentLength: number;
+    preview: string;
+}
+export interface BearTag {
+    name: string;
+    noteCount: number;
+}
+export declare function initBearDb(): Promise<boolean>;
+export declare function isBearAvailable(): boolean;
+/**
+ * Search notes by query (matches title and content).
+ */
+export declare function searchNotes(query: string, limit?: number): BearNoteCompact[];
+/**
+ * Get a single note by its unique identifier or title.
+ */
+export declare function getNote(identifier: string): BearNote | null;
+/**
+ * Get recently modified notes.
+ */
+export declare function getRecentNotes(limit?: number): BearNoteCompact[];
+/**
+ * Get notes by tag name.
+ */
+export declare function getNotesByTag(tag: string, limit?: number): BearNoteCompact[];
+/**
+ * List all tags with their note counts.
+ */
+export declare function listTags(): BearTag[];
+/**
+ * Get backlinks for a note (other notes that link to it).
+ */
+export declare function getBacklinks(identifier: string): BearNoteCompact[];
+/**
+ * Create a new note in Bear.
+ */
+export declare function createNote(title: string, content: string, tags?: string[]): Promise<void>;
+/**
+ * Append content to an existing note.
+ */
+export declare function appendToNote(identifier: string, content: string, options?: {
+    separator?: string;
+}): Promise<void>;
+/**
+ * Open a note in Bear.
+ */
+export declare function openNote(identifier: string): Promise<void>;

package/dist/bear.js

@@ -0,0 +1,273 @@
+/**
+ * Bear Notes Database Access
+ *
+ * Read-only access to Bear's local SQLite database via better-sqlite3.
+ * Write operations go through Bear's URL scheme (bear://x-callback-url/).
+ *
+ * Bear uses CoreData, so timestamps are seconds since Jan 1, 2001 (not Unix epoch).
+ * The offset is 978307200 seconds.
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+// CoreData epoch offset: seconds between Unix epoch (1970) and CoreData epoch (2001)
+const CORE_DATA_EPOCH_OFFSET = 978307200;
+const BEAR_DB_PATH = join(homedir(), "Library/Group Containers/9K33E3U3T4.net.shinyfrog.bear/Application Data/database.sqlite");
+let db = null;
+let dbLoadFailed = false;
+function coreDataToISO(timestamp) {
+    return new Date((timestamp + CORE_DATA_EPOCH_OFFSET) * 1000).toISOString();
+}
+async function ensureDb() {
+    if (db)
+        return db;
+    const mod = await import("better-sqlite3");
+    const BetterSqlite3 = mod.default ?? mod;
+    db = new BetterSqlite3(BEAR_DB_PATH, { readonly: true });
+    return db;
+}
+function getDbSync() {
+    if (!db)
+        throw new Error("Bear database not initialized. Call initBearDb() first.");
+    return db;
+}
+export async function initBearDb() {
+    if (db)
+        return true;
+    if (dbLoadFailed)
+        return false;
+    if (process.platform !== "darwin")
+        return false;
+    if (!existsSync(BEAR_DB_PATH))
+        return false;
+    try {
+        await ensureDb();
+        return true;
+    }
+    catch {
+        dbLoadFailed = true;
+        return false;
+    }
+}
+function extractPreview(text, maxLen = 200) {
+    if (!text)
+        return "";
+    // Strip Bear markdown header (first line is often the title prefixed with #)
+    const lines = text.split("\n");
+    const start = lines[0]?.startsWith("#") ? 1 : 0;
+    const body = lines.slice(start).join("\n").trim();
+    return body.length > maxLen ? body.slice(0, maxLen) + "…" : body;
+}
+// ---------------------------------------------------------------------------
+// Availability check
+// ---------------------------------------------------------------------------
+export function isBearAvailable() {
+    if (db)
+        return true;
+    if (dbLoadFailed)
+        return false;
+    if (process.platform !== "darwin")
+        return false;
+    return existsSync(BEAR_DB_PATH);
+}
+// ---------------------------------------------------------------------------
+// Read operations (SQLite)
+// ---------------------------------------------------------------------------
+const BASE_SELECT = `
+  SELECT
+    ZUNIQUEIDENTIFIER as id,
+    ZTITLE as title,
+    ZTEXT as content,
+    ZCREATIONDATE as createdAt,
+    ZMODIFICATIONDATE as modifiedAt,
+    ZPINNED as isPinned,
+    ZARCHIVED as isArchived
+  FROM ZSFNOTE
+  WHERE ZTRASHED = 0
+    AND ZPERMANENTLYDELETED = 0
+`;
+const COMPACT_SELECT = `
+  SELECT
+    ZUNIQUEIDENTIFIER as id,
+    ZTITLE as title,
+    ZCREATIONDATE as createdAt,
+    ZMODIFICATIONDATE as modifiedAt,
+    ZPINNED as isPinned,
+    ZARCHIVED as isArchived,
+    LENGTH(ZTEXT) as contentLength,
+    ZTEXT as content
+  FROM ZSFNOTE
+  WHERE ZTRASHED = 0
+    AND ZPERMANENTLYDELETED = 0
+`;
+function mapNote(row) {
+    return {
+        id: row.id,
+        title: row.title ?? "(untitled)",
+        content: row.content ?? "",
+        createdAt: coreDataToISO(row.createdAt),
+        modifiedAt: coreDataToISO(row.modifiedAt),
+        isPinned: row.isPinned === 1,
+        isArchived: row.isArchived === 1,
+    };
+}
+function mapNoteCompact(row) {
+    return {
+        id: row.id,
+        title: row.title ?? "(untitled)",
+        createdAt: coreDataToISO(row.createdAt),
+        modifiedAt: coreDataToISO(row.modifiedAt),
+        isPinned: row.isPinned === 1,
+        isArchived: row.isArchived === 1,
+        contentLength: row.contentLength ?? 0,
+        preview: extractPreview(row.content),
+    };
+}
+/**
+ * Search notes by query (matches title and content).
+ */
+export function searchNotes(query, limit = 20) {
+    const stmt = getDbSync().prepare(`
+    ${COMPACT_SELECT}
+      AND (ZTITLE LIKE ? OR ZTEXT LIKE ?)
+    ORDER BY ZMODIFICATIONDATE DESC
+    LIMIT ?
+  `);
+    const pattern = `%${query}%`;
+    const rows = stmt.all(pattern, pattern, limit);
+    return rows.map(mapNoteCompact);
+}
+/**
+ * Get a single note by its unique identifier or title.
+ */
+export function getNote(identifier) {
+    // Try UUID first
+    let stmt = getDbSync().prepare(`${BASE_SELECT} AND ZUNIQUEIDENTIFIER = ?`);
+    let row = stmt.get(identifier);
+    if (!row) {
+        // Fallback to title match (case-insensitive)
+        stmt = getDbSync().prepare(`${BASE_SELECT} AND LOWER(ZTITLE) = LOWER(?)`);
+        row = stmt.get(identifier);
+    }
+    return row ? mapNote(row) : null;
+}
+/**
+ * Get recently modified notes.
+ */
+export function getRecentNotes(limit = 20) {
+    const stmt = getDbSync().prepare(`
+    ${COMPACT_SELECT}
+    ORDER BY ZMODIFICATIONDATE DESC
+    LIMIT ?
+  `);
+    const rows = stmt.all(limit);
+    return rows.map(mapNoteCompact);
+}
+/**
+ * Get notes by tag name.
+ */
+export function getNotesByTag(tag, limit = 50) {
+    const stmt = getDbSync().prepare(`
+    ${COMPACT_SELECT}
+      AND Z_PK IN (
+        SELECT Z_5NOTES FROM Z_5TAGS
+        WHERE Z_13TAGS IN (
+          SELECT Z_PK FROM ZSFNOTETAG WHERE ZTITLE = ?
+        )
+      )
+    ORDER BY ZMODIFICATIONDATE DESC
+    LIMIT ?
+  `);
+    const rows = stmt.all(tag, limit);
+    return rows.map(mapNoteCompact);
+}
+/**
+ * List all tags with their note counts.
+ */
+export function listTags() {
+    const stmt = getDbSync().prepare(`
+    SELECT
+      t.ZTITLE as name,
+      COUNT(jt.Z_5NOTES) as noteCount
+    FROM ZSFNOTETAG t
+    LEFT JOIN Z_5TAGS jt ON jt.Z_13TAGS = t.Z_PK
+    LEFT JOIN ZSFNOTE n ON n.Z_PK = jt.Z_5NOTES
+      AND n.ZTRASHED = 0
+      AND n.ZPERMANENTLYDELETED = 0
+    WHERE t.ZTITLE IS NOT NULL
+    GROUP BY t.Z_PK
+    ORDER BY noteCount DESC
+  `);
+    return stmt.all();
+}
+/**
+ * Get backlinks for a note (other notes that link to it).
+ */
+export function getBacklinks(identifier) {
+    // First resolve to Z_PK
+    const pkStmt = getDbSync().prepare("SELECT Z_PK FROM ZSFNOTE WHERE ZUNIQUEIDENTIFIER = ? AND ZTRASHED = 0 AND ZPERMANENTLYDELETED = 0");
+    const pkRow = pkStmt.get(identifier);
+    if (!pkRow)
+        return [];
+    const stmt = getDbSync().prepare(`
+    ${COMPACT_SELECT}
+      AND Z_PK IN (
+        SELECT ZLINKEDBY FROM ZSFNOTEBACKLINK WHERE ZLINKINGTO = ?
+      )
+    ORDER BY ZMODIFICATIONDATE DESC
+  `);
+    const rows = stmt.all(pkRow.Z_PK);
+    return rows.map(mapNoteCompact);
+}
+// ---------------------------------------------------------------------------
+// Write operations (Bear URL scheme)
+// ---------------------------------------------------------------------------
+function openBearUrl(url) {
+    return new Promise((resolve, reject) => {
+        execFile("open", [url], (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+/**
+ * Create a new note in Bear.
+ */
+export async function createNote(title, content, tags) {
+    const params = new URLSearchParams({
+        title,
+        text: content,
+        open_note: "no",
+        new_window: "no",
+    });
+    if (tags?.length) {
+        params.set("tags", tags.join(","));
+    }
+    await openBearUrl(`bear://x-callback-url/create?${params.toString()}`);
+}
+/**
+ * Append content to an existing note.
+ */
+export async function appendToNote(identifier, content, options) {
+    const params = new URLSearchParams({
+        id: identifier,
+        text: content,
+        mode: "append",
+        open_note: "no",
+        new_window: "no",
+    });
+    if (options?.separator) {
+        params.set("text", `${options.separator}\n${content}`);
+    }
+    await openBearUrl(`bear://x-callback-url/add-text?${params.toString()}`);
+}
+/**
+ * Open a note in Bear.
+ */
+export async function openNote(identifier) {
+    const params = new URLSearchParams({ id: identifier });
+    await openBearUrl(`bear://x-callback-url/open-note?${params.toString()}`);
+}

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Portable Notes Sync CLI
+ *
+ * Syncs local notes (Bear, Obsidian, Apple Notes) to the Portable platform
+ * so your experts can search and reference them.
+ *
+ * Usage:
+ *   npx @portable/notes-sync --token pns_abc123...
+ *   npx @portable/notes-sync --token pns_abc123... --source bear
+ *   npx @portable/notes-sync --token pns_abc123... --source obsidian --verbose
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Portable Notes Sync CLI
+ *
+ * Syncs local notes (Bear, Obsidian, Apple Notes) to the Portable platform
+ * so your experts can search and reference them.
+ *
+ * Usage:
+ *   npx @portable/notes-sync --token pns_abc123...
+ *   npx @portable/notes-sync --token pns_abc123... --source bear
+ *   npx @portable/notes-sync --token pns_abc123... --source obsidian --verbose
+ */
+import { syncSource } from "./sync.js";
+import { isBearAvailable, initBearDb } from "./bear.js";
+import { isObsidianAvailable, getVaultPath } from "./obsidian.js";
+import { isAppleNotesAvailable } from "./apple-notes.js";
+const DEFAULT_BASE_URL = "https://portable.expert";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const parsed = {
+        token: "",
+        baseUrl: process.env.PORTABLE_BASE_URL ?? DEFAULT_BASE_URL,
+        verbose: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--token":
+            case "-t":
+                parsed.token = args[++i] ?? "";
+                break;
+            case "--source":
+            case "-s":
+                parsed.source = args[++i];
+                break;
+            case "--url":
+                parsed.baseUrl = args[++i] ?? DEFAULT_BASE_URL;
+                break;
+            case "--limit":
+                parsed.limit = parseInt(args[++i] ?? "0", 10) || undefined;
+                break;
+            case "--verbose":
+            case "-v":
+                parsed.verbose = true;
+                break;
+            case "--help":
+            case "-h":
+                printHelp();
+                process.exit(0);
+        }
+    }
+    if (!parsed.token) {
+        parsed.token = process.env.PORTABLE_SYNC_TOKEN ?? "";
+    }
+    return parsed;
+}
+function printHelp() {
+    console.log(`
+Portable Notes Sync
+
+Syncs your local notes to the Portable platform so your experts can
+search and reference them via RAG.
+
+Usage:
+  portable-notes-sync --token <sync-token>
+
+Options:
+  --token, -t    Sync token from Settings > Connections (required)
+  --source, -s   Only sync a specific source: bear, obsidian, apple-notes
+  --url          Platform URL (default: https://portable.expert)
+  --limit        Max notes to sync per source
+  --verbose, -v  Show detailed progress
+  --help, -h     Show this help
+
+Environment:
+  PORTABLE_SYNC_TOKEN    Alternative to --token
+  PORTABLE_BASE_URL      Alternative to --url
+
+Examples:
+  portable-notes-sync --token pns_abc123...
+  portable-notes-sync -t pns_abc123... --source bear -v
+  portable-notes-sync -t pns_abc123... --limit 100
+`);
+}
+async function main() {
+    const args = parseArgs();
+    if (!args.token) {
+        console.error("Error: Sync token is required.");
+        console.error("  Get one from Settings > Connections in your Portable dashboard.");
+        console.error("  Then run: portable-notes-sync --token pns_...\n");
+        process.exit(1);
+    }
+    if (!args.token.startsWith("pns_")) {
+        console.error("Error: Token must start with pns_ (got something else).");
+        console.error("  This looks like a different kind of token.");
+        console.error("  Get a Notes Sync token from Settings > Connections.\n");
+        process.exit(1);
+    }
+    console.log("Portable Notes Sync");
+    console.log("====================\n");
+    // Initialize Bear DB (async dynamic import of better-sqlite3)
+    await initBearDb();
+    const sources = [
+        { name: "Bear", key: "bear", available: isBearAvailable() },
+        { name: "Obsidian", key: "obsidian", available: isObsidianAvailable(), detail: getVaultPath() ?? undefined },
+        { name: "Apple Notes", key: "apple-notes", available: isAppleNotesAvailable() },
+    ];
+    console.log("Detected note sources:");
+    for (const s of sources) {
+        const status = s.available ? "found" : "not found";
+        const detail = s.detail ? ` (${s.detail})` : "";
+        console.log(`  ${s.available ? "+" : "-"} ${s.name}: ${status}${detail}`);
+    }
+    console.log();
+    const toSync = args.source
+        ? sources.filter((s) => s.key === args.source && s.available)
+        : sources.filter((s) => s.available);
+    if (toSync.length === 0) {
+        if (args.source) {
+            console.error(`Error: Source "${args.source}" not found on this machine.`);
+        }
+        else {
+            console.error("No note sources detected on this machine.");
+        }
+        process.exit(1);
+    }
+    const results = [];
+    for (const s of toSync) {
+        console.log(`Syncing ${s.name}...`);
+        const result = await syncSource(s.key, args.token, args.baseUrl, {
+            limit: args.limit,
+            verbose: args.verbose,
+        });
+        results.push(result);
+        if (result.errors.length > 0) {
+            for (const err of result.errors) {
+                console.error(`  Error: ${err}`);
+            }
+        }
+        console.log(`  Done: ${result.created} created, ${result.updated} updated, ${result.skipped} unchanged\n`);
+    }
+    console.log("Summary");
+    console.log("-------");
+    let totalCreated = 0;
+    let totalUpdated = 0;
+    let totalSkipped = 0;
+    for (const r of results) {
+        console.log(`  ${r.source}: ${r.total} notes (${r.created} new, ${r.updated} updated, ${r.skipped} unchanged)`);
+        totalCreated += r.created;
+        totalUpdated += r.updated;
+        totalSkipped += r.skipped;
+    }
+    console.log(`\nTotal: ${totalCreated} created, ${totalUpdated} updated, ${totalSkipped} unchanged`);
+    const hasErrors = results.some((r) => r.errors.length > 0);
+    if (hasErrors) {
+        console.error("\nSome errors occurred during sync. Check the messages above.");
+        process.exit(1);
+    }
+    console.log("\nYour experts can now search your notes.");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { isBearAvailable, initBearDb, searchNotes as bearSearch, getNote as bearGetNote, getRecentNotes as bearRecentNotes, listTags as bearListTags } from "./bear.js";
+export { isObsidianAvailable, getVaultPath, searchNotes as obsidianSearch, getNote as obsidianGetNote, getRecentNotes as obsidianRecentNotes, listTags as obsidianListTags } from "./obsidian.js";
+export { isAppleNotesAvailable, searchNotes as appleSearch, getNote as appleGetNote, getRecentNotes as appleRecentNotes, listFolders as appleListFolders } from "./apple-notes.js";
+export { syncSource, type SyncNote, type SyncResult } from "./sync.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { isBearAvailable, initBearDb, searchNotes as bearSearch, getNote as bearGetNote, getRecentNotes as bearRecentNotes, listTags as bearListTags } from "./bear.js";
+export { isObsidianAvailable, getVaultPath, searchNotes as obsidianSearch, getNote as obsidianGetNote, getRecentNotes as obsidianRecentNotes, listTags as obsidianListTags } from "./obsidian.js";
+export { isAppleNotesAvailable, searchNotes as appleSearch, getNote as appleGetNote, getRecentNotes as appleRecentNotes, listFolders as appleListFolders } from "./apple-notes.js";
+export { syncSource } from "./sync.js";

package/dist/obsidian.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Obsidian Vault Access
+ *
+ * Reads markdown files from an Obsidian vault directory.
+ * Writes via direct filesystem operations.
+ * Vault location is auto-detected or configured via OBSIDIAN_VAULT_PATH.
+ */
+export interface ObsidianNote {
+    path: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    modifiedAt: string;
+    tags: string[];
+    folder: string;
+}
+export interface ObsidianNoteCompact {
+    path: string;
+    title: string;
+    modifiedAt: string;
+    createdAt: string;
+    tags: string[];
+    folder: string;
+    contentLength: number;
+    preview: string;
+}
+export declare function isObsidianAvailable(): boolean;
+export declare function getVaultPath(): string | null;
+export declare function searchNotes(query: string, limit?: number): ObsidianNoteCompact[];
+export declare function getNote(identifier: string): ObsidianNote | null;
+export declare function getRecentNotes(limit?: number): ObsidianNoteCompact[];
+export declare function getNotesByTag(tag: string, limit?: number): ObsidianNoteCompact[];
+export declare function listTags(): Array<{
+    name: string;
+    noteCount: number;
+}>;
+export declare function createNote(title: string, content: string, folder?: string): string;
+export declare function appendToNote(identifier: string, content: string): void;

package/dist/obsidian.js

@@ -0,0 +1,293 @@
+/**
+ * Obsidian Vault Access
+ *
+ * Reads markdown files from an Obsidian vault directory.
+ * Writes via direct filesystem operations.
+ * Vault location is auto-detected or configured via OBSIDIAN_VAULT_PATH.
+ */
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, appendFileSync } from "node:fs";
+import { join, relative, basename, extname } from "node:path";
+import { homedir } from "node:os";
+// ---------------------------------------------------------------------------
+// Vault detection
+// ---------------------------------------------------------------------------
+let resolvedVaultPath = null;
+const COMMON_VAULT_LOCATIONS = [
+    "Documents",
+    "Obsidian",
+    "obsidian",
+    "Desktop",
+    "Notes",
+    "Library/Mobile Documents/iCloud~md~obsidian/Documents",
+];
+function findVaultPath() {
+    if (resolvedVaultPath)
+        return resolvedVaultPath;
+    const envPath = process.env.OBSIDIAN_VAULT_PATH?.trim();
+    if (envPath && existsSync(join(envPath, ".obsidian"))) {
+        resolvedVaultPath = envPath;
+        return resolvedVaultPath;
+    }
+    const home = homedir();
+    for (const loc of COMMON_VAULT_LOCATIONS) {
+        const candidate = join(home, loc);
+        if (!existsSync(candidate))
+            continue;
+        if (existsSync(join(candidate, ".obsidian"))) {
+            resolvedVaultPath = candidate;
+            return resolvedVaultPath;
+        }
+        // Check one level deeper for vaults inside common dirs
+        try {
+            const entries = readdirSync(candidate, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && existsSync(join(candidate, entry.name, ".obsidian"))) {
+                    resolvedVaultPath = join(candidate, entry.name);
+                    return resolvedVaultPath;
+                }
+            }
+        }
+        catch {
+            // Permission denied or similar
+        }
+    }
+    return null;
+}
+export function isObsidianAvailable() {
+    if (process.platform !== "darwin" && process.platform !== "linux" && process.platform !== "win32")
+        return false;
+    return findVaultPath() !== null;
+}
+export function getVaultPath() {
+    return findVaultPath();
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extractPreview(content, maxLen = 200) {
+    const lines = content.split("\n");
+    const start = lines[0]?.startsWith("#") ? 1 : 0;
+    const body = lines.slice(start).join("\n").trim();
+    return body.length > maxLen ? body.slice(0, maxLen) + "…" : body;
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith("---"))
+        return { frontmatter: {}, body: content };
+    const endIdx = content.indexOf("\n---", 3);
+    if (endIdx === -1)
+        return { frontmatter: {}, body: content };
+    const yamlBlock = content.slice(4, endIdx).trim();
+    const body = content.slice(endIdx + 4).trim();
+    const frontmatter = {};
+    for (const line of yamlBlock.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim();
+        if (key === "tags") {
+            // tags can be [tag1, tag2] or a YAML list
+            const cleaned = val.replace(/^\[|\]$/g, "");
+            frontmatter[key] = cleaned
+                .split(",")
+                .map((t) => t.trim().replace(/^#/, ""))
+                .filter(Boolean);
+        }
+        else {
+            frontmatter[key] = val;
+        }
+    }
+    return { frontmatter, body };
+}
+function extractInlineTags(content) {
+    const tagPattern = /(?:^|\s)#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
+    const tags = new Set();
+    let match;
+    while ((match = tagPattern.exec(content)) !== null) {
+        tags.add(match[1]);
+    }
+    return [...tags];
+}
+function walkMarkdownFiles(dir, vaultRoot) {
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith("."))
+                continue;
+            if (entry.name === "node_modules")
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...walkMarkdownFiles(fullPath, vaultRoot));
+            }
+            else if (extname(entry.name) === ".md") {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Permission denied
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Read operations
+// ---------------------------------------------------------------------------
+function readNoteFromPath(filePath, vaultRoot) {
+    const content = readFileSync(filePath, "utf-8");
+    const stat = statSync(filePath);
+    const { frontmatter, body } = parseFrontmatter(content);
+    const relPath = relative(vaultRoot, filePath);
+    const folder = relPath.includes("/") ? relPath.slice(0, relPath.lastIndexOf("/")) : "";
+    const fmTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
+    const inlineTags = extractInlineTags(body);
+    const allTags = [...new Set([...fmTags, ...inlineTags])];
+    return {
+        path: relPath,
+        title: basename(filePath, ".md"),
+        content,
+        createdAt: stat.birthtime.toISOString(),
+        modifiedAt: stat.mtime.toISOString(),
+        tags: allTags,
+        folder,
+    };
+}
+function toCompact(note) {
+    return {
+        path: note.path,
+        title: note.title,
+        modifiedAt: note.modifiedAt,
+        createdAt: note.createdAt,
+        tags: note.tags,
+        folder: note.folder,
+        contentLength: note.content.length,
+        preview: extractPreview(note.content),
+    };
+}
+export function searchNotes(query, limit = 20) {
+    const vault = findVaultPath();
+    if (!vault)
+        return [];
+    const files = walkMarkdownFiles(vault, vault);
+    const lowerQuery = query.toLowerCase();
+    const matches = [];
+    for (const file of files) {
+        if (matches.length >= limit)
+            break;
+        try {
+            const content = readFileSync(file, "utf-8");
+            const title = basename(file, ".md");
+            if (title.toLowerCase().includes(lowerQuery) || content.toLowerCase().includes(lowerQuery)) {
+                const note = readNoteFromPath(file, vault);
+                matches.push(toCompact(note));
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return matches;
+}
+export function getNote(identifier) {
+    const vault = findVaultPath();
+    if (!vault)
+        return null;
+    // Try as direct path first
+    let filePath = join(vault, identifier);
+    if (!filePath.endsWith(".md"))
+        filePath += ".md";
+    if (existsSync(filePath)) {
+        return readNoteFromPath(filePath, vault);
+    }
+    // Fallback: search by title
+    const files = walkMarkdownFiles(vault, vault);
+    const lowerIdent = identifier.toLowerCase();
+    for (const file of files) {
+        if (basename(file, ".md").toLowerCase() === lowerIdent) {
+            return readNoteFromPath(file, vault);
+        }
+    }
+    return null;
+}
+export function getRecentNotes(limit = 20) {
+    const vault = findVaultPath();
+    if (!vault)
+        return [];
+    const files = walkMarkdownFiles(vault, vault);
+    const withMtime = files.map((f) => {
+        try {
+            return { path: f, mtime: statSync(f).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    }).filter((x) => x !== null);
+    withMtime.sort((a, b) => b.mtime - a.mtime);
+    return withMtime.slice(0, limit).map((f) => toCompact(readNoteFromPath(f.path, vault)));
+}
+export function getNotesByTag(tag, limit = 50) {
+    const vault = findVaultPath();
+    if (!vault)
+        return [];
+    const files = walkMarkdownFiles(vault, vault);
+    const results = [];
+    const lowerTag = tag.toLowerCase();
+    for (const file of files) {
+        if (results.length >= limit)
+            break;
+        try {
+            const note = readNoteFromPath(file, vault);
+            if (note.tags.some((t) => t.toLowerCase() === lowerTag)) {
+                results.push(toCompact(note));
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    return results;
+}
+export function listTags() {
+    const vault = findVaultPath();
+    if (!vault)
+        return [];
+    const files = walkMarkdownFiles(vault, vault);
+    const tagCounts = new Map();
+    for (const file of files) {
+        try {
+            const note = readNoteFromPath(file, vault);
+            for (const tag of note.tags) {
+                tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    return [...tagCounts.entries()]
+        .map(([name, noteCount]) => ({ name, noteCount }))
+        .sort((a, b) => b.noteCount - a.noteCount);
+}
+// ---------------------------------------------------------------------------
+// Write operations
+// ---------------------------------------------------------------------------
+export function createNote(title, content, folder) {
+    const vault = findVaultPath();
+    if (!vault)
+        throw new Error("No Obsidian vault found");
+    const dir = folder ? join(vault, folder) : vault;
+    const filePath = join(dir, `${title}.md`);
+    if (existsSync(filePath))
+        throw new Error(`Note already exists: ${filePath}`);
+    writeFileSync(filePath, content, "utf-8");
+    return relative(vault, filePath);
+}
+export function appendToNote(identifier, content) {
+    const note = getNote(identifier);
+    if (!note)
+        throw new Error(`Note not found: ${identifier}`);
+    const vault = findVaultPath();
+    const filePath = join(vault, note.path);
+    appendFileSync(filePath, `\n${content}`, "utf-8");
+}

package/dist/sync.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Notes Sync Engine
+ *
+ * Reads notes from local sources (Bear, Obsidian, Apple Notes) and
+ * pushes them to the Portable platform via POST /api/pep/sync-notes.
+ *
+ * Used by both the standalone CLI (sync-entry.ts) and auto-sync on
+ * MCP server startup.
+ */
+export interface SyncNote {
+    externalId: string;
+    title: string;
+    content: string;
+    source: "bear" | "obsidian" | "apple-notes";
+    tags?: string[];
+    folder?: string;
+    createdAt?: string;
+    modifiedAt?: string;
+}
+export interface SyncResult {
+    source: string;
+    total: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    errors: string[];
+}
+export declare function syncSource(source: "bear" | "obsidian" | "apple-notes", token: string, baseUrl: string, options?: {
+    limit?: number;
+    verbose?: boolean;
+}): Promise<SyncResult>;

package/dist/sync.js

@@ -0,0 +1,135 @@
+/**
+ * Notes Sync Engine
+ *
+ * Reads notes from local sources (Bear, Obsidian, Apple Notes) and
+ * pushes them to the Portable platform via POST /api/pep/sync-notes.
+ *
+ * Used by both the standalone CLI (sync-entry.ts) and auto-sync on
+ * MCP server startup.
+ */
+import { isBearAvailable, initBearDb, searchNotes as bearSearch, getNote as bearGetNote } from "./bear.js";
+import { isObsidianAvailable, getRecentNotes as obsidianRecent, getNote as obsidianGetNote, searchNotes as obsidianSearch } from "./obsidian.js";
+import { isAppleNotesAvailable, getRecentNotes as appleRecent, getNote as appleGetNote } from "./apple-notes.js";
+const BATCH_SIZE = 50;
+export async function syncSource(source, token, baseUrl, options = {}) {
+    const { limit, verbose } = options;
+    const result = { source, total: 0, created: 0, updated: 0, skipped: 0, errors: [] };
+    if (source === "bear")
+        await initBearDb();
+    let notes;
+    try {
+        notes = readLocalNotes(source, limit);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        result.errors.push(`Failed to read ${source} notes: ${msg}`);
+        return result;
+    }
+    result.total = notes.length;
+    if (verbose)
+        console.log(`  Read ${notes.length} notes from ${source}`);
+    for (let i = 0; i < notes.length; i += BATCH_SIZE) {
+        const batch = notes.slice(i, i + BATCH_SIZE);
+        if (verbose)
+            console.log(`  Syncing batch ${Math.floor(i / BATCH_SIZE) + 1}/${Math.ceil(notes.length / BATCH_SIZE)} (${batch.length} notes)...`);
+        try {
+            const response = await fetch(`${baseUrl}/api/pep/sync-notes`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({ notes: batch }),
+            });
+            if (!response.ok) {
+                const errBody = await response.text();
+                result.errors.push(`HTTP ${response.status}: ${errBody.slice(0, 200)}`);
+                continue;
+            }
+            const data = (await response.json());
+            if (data.summary) {
+                result.created += data.summary.created;
+                result.updated += data.summary.updated;
+                result.skipped += data.summary.skipped;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            result.errors.push(`Network error: ${msg}`);
+        }
+    }
+    return result;
+}
+function readLocalNotes(source, limit) {
+    switch (source) {
+        case "bear":
+            return readBearNotes(limit);
+        case "obsidian":
+            return readObsidianNotes(limit);
+        case "apple-notes":
+            return readAppleNotes(limit);
+    }
+}
+function readBearNotes(limit) {
+    if (!isBearAvailable())
+        return [];
+    const compactNotes = bearSearch("", limit ?? 10000);
+    const notes = [];
+    for (const compact of compactNotes) {
+        const full = bearGetNote(compact.id);
+        if (!full)
+            continue;
+        notes.push({
+            externalId: full.id,
+            title: full.title,
+            content: full.content,
+            source: "bear",
+            createdAt: full.createdAt,
+            modifiedAt: full.modifiedAt,
+        });
+    }
+    return notes;
+}
+function readObsidianNotes(limit) {
+    if (!isObsidianAvailable())
+        return [];
+    const compactNotes = limit ? obsidianRecent(limit) : obsidianSearch("", 10000);
+    const notes = [];
+    for (const compact of compactNotes) {
+        const full = obsidianGetNote(compact.path);
+        if (!full)
+            continue;
+        notes.push({
+            externalId: compact.path,
+            title: full.title,
+            content: full.content,
+            source: "obsidian",
+            tags: full.tags,
+            folder: full.folder,
+            createdAt: full.createdAt,
+            modifiedAt: full.modifiedAt,
+        });
+    }
+    return notes;
+}
+function readAppleNotes(limit) {
+    if (!isAppleNotesAvailable())
+        return [];
+    const compactNotes = appleRecent(limit ?? 500);
+    const notes = [];
+    for (const compact of compactNotes) {
+        const full = appleGetNote(compact.id);
+        if (!full)
+            continue;
+        notes.push({
+            externalId: full.id,
+            title: full.title,
+            content: full.content,
+            source: "apple-notes",
+            folder: full.folder,
+            createdAt: full.createdAt,
+            modifiedAt: full.modifiedAt,
+        });
+    }
+    return notes;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@portablecore/notes-sync",
+  "version": "0.1.0",
+  "description": "Sync your local notes (Bear, Obsidian, Apple Notes) to the Portable platform",
+  "type": "module",
+  "bin": {
+    "portable-notes-sync": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "portable",
+    "notes",
+    "bear",
+    "obsidian",
+    "apple-notes",
+    "sync"
+  ],
+  "author": "Portable",
+  "license": "UNLICENSED",
+  "optionalDependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "@types/node": "^22.0.0",
+    "@types/better-sqlite3": "^7.6.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}