aaak-vault-sync 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "aaak-vault-sync",
+  "version": "1.0.0",
+  "description": "Sync an Obsidian vault to AAAK memory format for LLM context loading",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "bin": {
+    "aaak-scan": "bin/aaak-scan.js"
+  },
+  "scripts": {
+    "setup": "node scripts/setup.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "templates/",
+    "scan.py",
+    "dialect.py"
+  ],
+  "keywords": [
+    "obsidian",
+    "llm",
+    "memory",
+    "aaak",
+    "claude"
+  ]
+}

package/scan.py

@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""
+scan.py — Obsidian vault → AAAK memory sync
+
+Scans an Obsidian vault for new or updated markdown files, converts them
+to AAAK format using dialect.py, and maintains an index at $VAULT/aaak/aaak_index.md.
+
+Usage:
+    OBSIDIAN_VAULT_PATH=/path/to/vault python scan.py
+    OBSIDIAN_VAULT_PATH=/path/to/vault python scan.py --dry-run
+    OBSIDIAN_VAULT_PATH=/path/to/vault python scan.py --verbose
+    OBSIDIAN_VAULT_PATH=/path/to/vault python scan.py --force   # re-scan all files
+"""
+
+import os
+import sys
+import json
+import re
+import argparse
+from pathlib import Path
+from datetime import datetime, timezone
+
+# Import Dialect from the same directory as scan.py
+sys.path.insert(0, str(Path(__file__).parent))
+from dialect import Dialect
+
+# === CONSTANTS ===
+
+AAAK_SUBDIR = "aaak"
+INDEX_FILENAME = "aaak_index.md"
+INDEX_JSON_FILENAME = "aaak_index.json"
+ENTITIES_FILENAME = "entities.json"
+
+
+# === ENTITY AUTO-DETECTION ===
+
+# Match two or more consecutive Title-Case words on the same line (people, orgs, project names)
+# Use [ \t]+ instead of \s+ to avoid matching across newlines
+_NAME_RE = re.compile(r'\b([A-Z][a-z]+(?:[ \t]+[A-Z][a-z]+)+)\b')
+
+
+def _generate_code(name: str, used: set) -> str:
+    """Generate a unique 3-char code for a proper noun name."""
+    parts = name.split()
+    # e.g. "Alice Johnson" -> "ALJ", "Project Falcon" -> "PRF"
+    base = (parts[0][:2] + parts[-1][0]).upper()
+    code = base
+    suffix = 0
+    while code in used:
+        suffix += 1
+        code = base[:2] + str(suffix)
+    return code
+
+
+def detect_entities(vault_path: Path, existing: dict) -> dict:
+    """
+    Scan vault markdown files for capitalized proper nouns.
+    Returns merged dict: {full_name: 3-char-code}.
+    Preserves existing codes so they remain stable across runs.
+    """
+    aaak_dir = vault_path / AAAK_SUBDIR
+    found = set()
+
+    for md_file in vault_path.rglob("*.md"):
+        if aaak_dir in md_file.parents or md_file.parent == aaak_dir:
+            continue
+        try:
+            text = md_file.read_text(errors="replace")
+            found.update(_NAME_RE.findall(text))
+        except OSError:
+            pass  # skip unreadable files
+
+    entities = dict(existing)  # preserve existing codes
+    used_codes = set(entities.values())
+
+    for name in sorted(found):
+        if name not in entities:
+            code = _generate_code(name, used_codes)
+            entities[name] = code
+            used_codes.add(code)
+
+    return entities
+
+
+def load_entities(aaak_dir: Path) -> dict:
+    """Load entities.json from aaak dir. Returns empty dict if not found."""
+    path = aaak_dir / ENTITIES_FILENAME
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_entities(aaak_dir: Path, entities: dict, dry_run: bool = False) -> None:
+    """Write entities.json to aaak dir."""
+    if dry_run:
+        return
+    (aaak_dir / ENTITIES_FILENAME).write_text(
+        json.dumps(entities, indent=2, sort_keys=True) + "\n"
+    )
+
+
+# === INDEX MANAGEMENT ===
+
+def load_index(aaak_dir: Path) -> dict:
+    """
+    Load aaak_index.md. Returns dict keyed by source rel_path.
+    Parses the embedded JSON block between <!-- INDEX_DATA and -->.
+    Falls back to empty dict if file missing or malformed.
+    """
+    index_path = aaak_dir / INDEX_FILENAME
+    if not index_path.exists():
+        return {}
+    try:
+        text = index_path.read_text()
+        match = re.search(r'<!-- INDEX_DATA\n(.*?)\n-->', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(1))
+    except (OSError, json.JSONDecodeError) as e:
+        print(f"[warn] Could not parse existing index ({e}), starting fresh")
+    return {}
+
+
+def save_index(aaak_dir: Path, index: dict, dry_run: bool = False) -> None:
+    """
+    Write both:
+    - aaak_index.md for humans and text-native LLMs
+    - aaak_index.json for tooling and provider-agnostic integrations
+    """
+    entries = sorted(index.values(), key=lambda e: e["source"])
+
+    lines = [
+        "# AAAK Memory Index",
+        "",
+        "_Auto-generated by scan.py. Check this file to find vault context relevant to your current task._",
+        "",
+        "## How to Use",
+        "",
+        "1. Scan the **Topics** column for keywords relevant to the current conversation.",
+        "2. If relevant, read the linked AAAK file for a compressed summary.",
+        "3. If you need full detail, follow the `SOURCE:` line in the AAAK file back to the original markdown.",
+        "",
+        "## Tracked Files",
+        "",
+        "| Source | AAAK | Last Scanned | Topics |",
+        "|--------|------|--------------|--------|",
+    ]
+
+    for entry in entries:
+        source = entry["source"]
+        aaak = entry["aaak_path"]
+        scanned = entry["last_scanned"][:10]  # date only
+        summary = entry.get("summary", "")
+        lines.append(f"| `{source}` | `{aaak}` | {scanned} | {summary} |")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "<!-- INDEX_DATA",
+        json.dumps(index, indent=2, sort_keys=True),
+        "-->",
+    ]
+
+    md_content = "\n".join(lines) + "\n"
+    json_content = json.dumps(
+        {
+            "version": 1,
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "entries": entries,
+        },
+        indent=2,
+        sort_keys=True,
+    ) + "\n"
+
+    if dry_run:
+        print(f"[dry-run] Would write {aaak_dir / INDEX_FILENAME} ({len(entries)} entries)")
+        print(f"[dry-run] Would write {aaak_dir / INDEX_JSON_FILENAME} ({len(entries)} entries)")
+        return
+
+    (aaak_dir / INDEX_FILENAME).write_text(md_content)
+    (aaak_dir / INDEX_JSON_FILENAME).write_text(json_content)
+
+
+# === VAULT WALKER ===
+
+def find_candidates(vault_path: Path, index: dict, force: bool = False) -> list:
+    """
+    Return list of vault .md files that need processing:
+    - Not yet in index (new files)
+    - In index but mtime > last_scanned_ts (updated files)
+    - All files if force=True
+    """
+    aaak_dir = vault_path / AAAK_SUBDIR
+    candidates = []
+
+    for md_file in sorted(vault_path.rglob("*.md")):
+        # Skip the aaak/ output directory to prevent recursion
+        if aaak_dir in md_file.parents or md_file.parent == aaak_dir:
+            continue
+
+        rel_path = str(md_file.relative_to(vault_path))
+        mtime = md_file.stat().st_mtime
+
+        if force or rel_path not in index:
+            candidates.append(md_file)
+        elif mtime > index[rel_path]["last_scanned_ts"]:
+            candidates.append(md_file)
+
+    return candidates
+
+
+# === AAAK CONVERSION ===
+
+def slug_from_path(rel_path: str) -> str:
+    """
+    Convert a relative vault path to a safe AAAK filename slug.
+    Example: "projects/my-note.md" -> "projects--my-note.aaak.md"
+    """
+    return rel_path.replace("/", "--").replace("\\", "--").replace(".md", ".aaak.md")
+
+
+def _extract_index_summary(aaak_content: str) -> str:
+    """Pull topic keywords from the first zettel content line for index display."""
+    for line in aaak_content.splitlines():
+        if "|" not in line:
+            continue
+        if line.startswith("T:") or line.startswith("ARC:"):
+            continue
+        parts = line.split("|")
+        if len(parts) < 2:
+            continue
+        first_field = parts[0].strip()
+        # Zettel content lines start with a ZID: "0:ENTITIES" (contains a colon)
+        # Header lines look like "wing|room|date|title" (no colon in first field)
+        if ":" not in first_field:
+            continue  # skip header line
+        candidate = parts[1].strip()
+        if candidate:
+            return candidate[:80]
+    return ""
+
+
+def convert_file(
+    md_file: Path,
+    vault_path: Path,
+    aaak_dir: Path,
+    dialect: Dialect,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> dict:
+    """
+    Compress one markdown file to AAAK format. Returns an index entry dict.
+    Writes the AAAK file to aaak_dir unless dry_run=True.
+    """
+    rel_path = str(md_file.relative_to(vault_path))
+    slug = slug_from_path(rel_path)
+    aaak_path = aaak_dir / slug
+
+    try:
+        content = md_file.read_text(errors="replace")
+    except OSError as e:
+        print(f"[warn] Could not read {rel_path}: {e}")
+        return None
+
+    mtime = md_file.stat().st_mtime
+    date_str = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d")
+
+    metadata = {
+        "source_file": rel_path,
+        "date": date_str,
+    }
+
+    try:
+        aaak_content = dialect.compress(content, metadata)
+    except Exception as e:
+        print(f"[warn] Could not compress {rel_path}: {e}")
+        return None
+
+    # Prepend SOURCE reference so Claude can trace back to the original
+    full_output = f"SOURCE: {rel_path}\n{aaak_content}\n"
+
+    if verbose:
+        print(f"  [convert] {rel_path} -> {slug}")
+
+    if not dry_run:
+        aaak_path.parent.mkdir(parents=True, exist_ok=True)
+        aaak_path.write_text(full_output)
+
+    summary = _extract_index_summary(aaak_content)
+
+    return {
+        "source": rel_path,
+        "aaak_path": str(aaak_path.relative_to(vault_path)),
+        "last_scanned_ts": mtime,
+        "last_scanned": datetime.fromtimestamp(mtime, tz=timezone.utc).isoformat(),
+        "summary": summary,
+    }
+
+
+# === MAIN ===
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Sync Obsidian vault to AAAK memory format.",
+        epilog="Set OBSIDIAN_VAULT_PATH env var to your vault directory.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without writing any files",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Print each file being processed",
+    )
+    parser.add_argument(
+        "--force", "-f",
+        action="store_true",
+        help="Re-scan all files, even if they haven't changed",
+    )
+    args = parser.parse_args()
+
+    # --- Validate vault path ---
+    vault_str = os.environ.get("OBSIDIAN_VAULT_PATH", "").strip()
+    if not vault_str:
+        print("Error: OBSIDIAN_VAULT_PATH environment variable is not set.")
+        print("Usage: OBSIDIAN_VAULT_PATH=/path/to/vault python scan.py")
+        sys.exit(1)
+
+    vault_path = Path(vault_str)
+    if not vault_path.exists():
+        print(f"Error: Vault path does not exist: {vault_path}")
+        sys.exit(1)
+    if not vault_path.is_dir():
+        print(f"Error: Vault path is not a directory: {vault_path}")
+        sys.exit(1)
+
+    aaak_dir = vault_path / AAAK_SUBDIR
+
+    # --- Create aaak/ dir ---
+    if not dry_run_guard(args.dry_run, aaak_dir):
+        return
+
+    # --- Load existing state ---
+    index = load_index(aaak_dir)
+    existing_entities = load_entities(aaak_dir)
+
+    if args.verbose:
+        print(f"Vault: {vault_path}")
+        print(f"Index: {len(index)} tracked files")
+        print(f"Entities: {len(existing_entities)} known")
+
+    # --- Detect entities from vault ---
+    entities = detect_entities(vault_path, existing_entities)
+    new_entity_count = len(entities) - len(existing_entities)
+    if args.verbose and new_entity_count > 0:
+        print(f"Entities: found {new_entity_count} new proper nouns")
+
+    # --- Build Dialect instance with detected entities ---
+    dialect = Dialect(entities=entities)
+
+    # --- Find candidates ---
+    candidates = find_candidates(vault_path, index, force=args.force)
+
+    if args.verbose or args.dry_run:
+        print(f"Candidates: {len(candidates)} file(s) to process")
+
+    if not candidates:
+        print("Nothing to do — all files are up to date.")
+        if args.verbose:
+            save_entities(aaak_dir, entities, dry_run=args.dry_run)
+        return
+
+    # --- Process each candidate ---
+    processed = 0
+    skipped = 0
+
+    for md_file in candidates:
+        entry = convert_file(
+            md_file, vault_path, aaak_dir, dialect,
+            dry_run=args.dry_run, verbose=args.verbose,
+        )
+        if entry is not None:
+            index[entry["source"]] = entry
+            processed += 1
+        else:
+            skipped += 1
+
+    # --- Save index and entities ---
+    save_index(aaak_dir, index, dry_run=args.dry_run)
+    save_entities(aaak_dir, entities, dry_run=args.dry_run)
+
+    # --- Report ---
+    action = "[dry-run] Would process" if args.dry_run else "Processed"
+    print(f"{action} {processed} file(s)", end="")
+    if skipped:
+        print(f", skipped {skipped} (errors)", end="")
+    print(f". Index: {len(index)} total tracked.")
+
+
+def dry_run_guard(is_dry_run: bool, aaak_dir: Path) -> bool:
+    """
+    Ensure aaak_dir exists (or report it would be created in dry-run mode).
+    Returns False if creation failed and execution should stop.
+    """
+    if aaak_dir.exists():
+        return True
+    if is_dry_run:
+        print(f"[dry-run] Would create directory: {aaak_dir}")
+        return True
+    try:
+        aaak_dir.mkdir(parents=True, exist_ok=True)
+        return True
+    except OSError as e:
+        print(f"Error: Could not create aaak directory {aaak_dir}: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    main()

package/scripts/setup.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * aaak-vault-sync setup
+ *
+ * Installs:
+ *   1. launchd agent         → ~/Library/LaunchAgents/com.aaak.vault-sync.plist
+ *   2. generic prompt file   → ~/.aaak/generic-memory-loader.md
+ *   3. optional Claude files → ~/.claude/skills/scan-vault/SKILL.md and ~/.claude/CLAUDE.md
+ *
+ * Usage:
+ *   npm run setup
+ *   node scripts/setup.js
+ *   node scripts/setup.js --target none
+ *   node scripts/setup.js --target claude
+ *   OBSIDIAN_VAULT_PATH=/path/to/vault node scripts/setup.js --target claude
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const HOME = os.homedir();
+const PLATFORM = os.platform();
+
+// ── Paths ──────────────────────────────────────────────────────────────────
+
+const LAUNCH_AGENTS_DIR = path.join(HOME, 'Library', 'LaunchAgents');
+const PLIST_DEST        = path.join(LAUNCH_AGENTS_DIR, 'com.aaak.vault-sync.plist');
+const CLAUDE_DIR        = path.join(HOME, '.claude');
+const SKILLS_DIR        = path.join(CLAUDE_DIR, 'skills', 'scan-vault');
+const SKILL_DEST        = path.join(SKILLS_DIR, 'SKILL.md');
+const CLAUDE_MD_PATH    = path.join(CLAUDE_DIR, 'CLAUDE.md');
+const AAAK_DIR          = path.join(HOME, '.aaak');
+const GENERIC_PROMPT_DEST = path.join(AAAK_DIR, 'generic-memory-loader.md');
+
+const PLIST_TEMPLATE    = path.join(PACKAGE_ROOT, 'templates', 'com.aaak.vault-sync.plist.template');
+const SKILL_TEMPLATE    = path.join(PACKAGE_ROOT, 'templates', 'scan-vault-skill.md.template');
+const GENERIC_PROMPT_TEMPLATE = path.join(PACKAGE_ROOT, 'templates', 'generic-memory-loader.md.template');
+const SCAN_PY           = path.join(PACKAGE_ROOT, 'scan.py');
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function findPython() {
+  for (const cmd of ['python3', 'python']) {
+    try {
+      const p = execSync(`which ${cmd} 2>/dev/null`).toString().trim();
+      if (p) return p;
+    } catch (_) {}
+  }
+  return '/usr/bin/python3'; // safe fallback on macOS
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function log(msg)  { console.log(`  ${msg}`); }
+function ok(msg)   { console.log(`\u2713 ${msg}`); }
+function warn(msg) { console.log(`\u26a0 ${msg}`); }
+function bold(msg) { return `\x1b[1m${msg}\x1b[0m`; }
+
+// ── Steps ──────────────────────────────────────────────────────────────────
+
+function installLaunchdAgent(vaultPath, python) {
+  if (PLATFORM !== 'darwin') {
+    warn('Skipping launchd agent (macOS only). Set up a cron job manually instead:');
+    log(`  crontab -e  →  0 * * * * OBSIDIAN_VAULT_PATH=${vaultPath || '/path/to/vault'} ${python} ${SCAN_PY}`);
+    return;
+  }
+
+  const template = fs.readFileSync(PLIST_TEMPLATE, 'utf8');
+  const plist = template
+    .replace('{{PYTHON}}',     python)
+    .replace('{{SCAN_PY}}',    SCAN_PY)
+    .replace('{{VAULT_PATH}}', vaultPath || 'YOUR_VAULT_PATH_HERE');
+
+  ensureDir(LAUNCH_AGENTS_DIR);
+  fs.writeFileSync(PLIST_DEST, plist);
+  ok(`Plist written: ${PLIST_DEST}`);
+
+  if (!vaultPath) {
+    warn(`OBSIDIAN_VAULT_PATH not set — edit the plist before loading:`);
+    log(`  ${PLIST_DEST}`);
+    log(`  Replace YOUR_VAULT_PATH_HERE with your vault path, then:`);
+    log(`  launchctl load "${PLIST_DEST}"`);
+  } else {
+    log(`Vault path: ${vaultPath}`);
+    log(`To activate: launchctl load "${PLIST_DEST}"`);
+  }
+}
+
+function installGenericPromptFile() {
+  ensureDir(AAAK_DIR);
+  const prompt = fs.readFileSync(GENERIC_PROMPT_TEMPLATE, 'utf8');
+  fs.writeFileSync(GENERIC_PROMPT_DEST, prompt);
+  ok(`Generic prompt installed: ${GENERIC_PROMPT_DEST}`);
+  log('Use this file with any LLM that supports system prompts or custom instructions');
+}
+
+function installClaudeSkill() {
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    warn(`~/.claude/ not found — is Claude Code installed? Skipping skill install.`);
+    log(`You can install manually later: mkdir -p ${SKILLS_DIR} && cp ${SKILL_TEMPLATE} ${SKILL_DEST}`);
+    return;
+  }
+
+  ensureDir(SKILLS_DIR);
+  const skill = fs.readFileSync(SKILL_TEMPLATE, 'utf8');
+  fs.writeFileSync(SKILL_DEST, skill);
+  ok(`Skill installed: ${SKILL_DEST}`);
+  log(`Invoke with /scan-vault in any Claude Code session`);
+}
+
+function installClaudeMdRule() {
+  const rule = [
+    '',
+    '## Obsidian Vault Memory',
+    '',
+    'I maintain an AAAK memory index of my Obsidian vault at:',
+    '`$OBSIDIAN_VAULT_PATH/aaak/aaak_index.md`',
+    '',
+    '**At the start of each session**, if `OBSIDIAN_VAULT_PATH` is set and the index file exists:',
+    '1. Read `$OBSIDIAN_VAULT_PATH/aaak/aaak_index.md`',
+    '2. Scan the Topics column for entries relevant to what the user is working on',
+    '3. For relevant entries, read the linked AAAK file (column 2, relative to vault root) for a compressed summary',
+    '4. If deeper detail is needed, follow the `SOURCE:` line in the AAAK file to read the original markdown',
+    '',
+    '**During the session**, re-check the index if a new topic arises that might have vault context.',
+    '',
+    'If `OBSIDIAN_VAULT_PATH` is not set or the index file does not exist yet, silently skip.',
+    '',
+    'To refresh the vault index from within a session, use the `/scan-vault` skill.',
+    '',
+  ].join('\n');
+
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    warn(`~/.claude/ not found — skipping CLAUDE.md update.`);
+    return;
+  }
+
+  if (fs.existsSync(CLAUDE_MD_PATH)) {
+    const existing = fs.readFileSync(CLAUDE_MD_PATH, 'utf8');
+    if (existing.includes('## Obsidian Vault Memory')) {
+      ok(`CLAUDE.md already has vault memory rule — skipping`);
+      return;
+    }
+    fs.appendFileSync(CLAUDE_MD_PATH, rule);
+    ok(`CLAUDE.md updated: ${CLAUDE_MD_PATH}`);
+  } else {
+    fs.writeFileSync(CLAUDE_MD_PATH, rule.trimStart());
+    ok(`CLAUDE.md created: ${CLAUDE_MD_PATH}`);
+  }
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log(bold('\naaak-vault-sync setup\n'));
+
+  const vaultPath = process.env.OBSIDIAN_VAULT_PATH || '';
+  const python    = findPython();
+  const args = process.argv.slice(2);
+  const targetIdx = args.indexOf('--target');
+  const target = targetIdx >= 0 && args[targetIdx + 1] ? args[targetIdx + 1] : 'none';
+
+  log(`scan.py:  ${SCAN_PY}`);
+  log(`python3:  ${python}`);
+  log(`vault:    ${vaultPath || '(not set; OBSIDIAN_VAULT_PATH is empty)'}`);
+  log(`target:   ${target}\n`);
+
+  installLaunchdAgent(vaultPath, python);
+  console.log('');
+  installGenericPromptFile();
+
+  if (target === 'claude') {
+    console.log('');
+    installClaudeSkill();
+    console.log('');
+    installClaudeMdRule();
+  } else {
+    console.log('');
+    log('Skipping Claude-specific integration. Use --target claude to install it.');
+  }
+
+  console.log(bold('\nNext steps:'));
+  if (!vaultPath) {
+    log('1. Add to ~/.zshrc (or ~/.bashrc):');
+    log('     export OBSIDIAN_VAULT_PATH=/path/to/your/vault');
+    log('   Then re-run: npm run setup');
+    log('');
+  }
+  if (PLATFORM === 'darwin') {
+    const loadCmd = `launchctl load "${PLIST_DEST}"`;
+    log(`${vaultPath ? '1' : '2'}. Load the scheduler:`);
+    log(`     ${loadCmd}`);
+    log('');
+    log(`${vaultPath ? '2' : '3'}. Run a manual sync to verify:`);
+  } else {
+    log(`${vaultPath ? '1' : '2'}. Run a manual sync to verify:`);
+  }
+  log('     aaak-scan --verbose');
+  log('');
+  log(`${vaultPath ? '3' : '4'}. Reuse this prompt with any LLM:`);
+  log(`     ${GENERIC_PROMPT_DEST}`);
+  console.log('');
+}
+
+main();

package/templates/com.aaak.vault-sync.plist.template

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.aaak.vault-sync</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>{{PYTHON}}</string>
+        <string>{{SCAN_PY}}</string>
+    </array>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>OBSIDIAN_VAULT_PATH</key>
+        <string>{{VAULT_PATH}}</string>
+    </dict>
+
+    <key>StartInterval</key>
+    <integer>3600</integer>
+
+    <key>StandardOutPath</key>
+    <string>/tmp/aaak-vault-sync.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/tmp/aaak-vault-sync.err</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+</dict>
+</plist>