@aperdomoll90/ledger-ai 1.0.0

package/dist/commands/ingest.js

@@ -0,0 +1,221 @@
+import { readFileSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { resolve, basename } from 'path';
+import { fetchCachedNotes, searchNotes } from '../lib/notes.js';
+import { contentHash } from '../lib/hash.js';
+import { confirm, choose } from '../lib/prompt.js';
+export async function ingest(config, options) {
+    const existingNotes = await fetchCachedNotes(config.supabase);
+    if (options.file) {
+        if (options.auto) {
+            await autoIngestFile(config, resolve(options.file), existingNotes);
+        }
+        else {
+            await ingestFile(config, resolve(options.file), existingNotes);
+        }
+        return;
+    }
+    // Scan memory dir for unknown files
+    if (!existsSync(config.memoryDir)) {
+        console.error('Memory directory not found.');
+        return;
+    }
+    const knownFiles = new Set(existingNotes
+        .map(n => n.metadata.local_file)
+        .filter(Boolean));
+    const localFiles = readdirSync(config.memoryDir)
+        .filter(f => f.endsWith('.md') && f !== 'MEMORY.md' && !knownFiles.has(f));
+    if (localFiles.length === 0) {
+        console.error('No unknown files found.');
+        return;
+    }
+    console.error(`Found ${localFiles.length} unknown file(s):\n`);
+    for (const file of localFiles) {
+        const filePath = resolve(config.memoryDir, file);
+        await ingestFile(config, filePath, existingNotes);
+        console.error('');
+    }
+}
+async function ingestFile(config, filePath, existingNotes) {
+    const filename = basename(filePath);
+    const content = readFileSync(filePath, 'utf-8').trim();
+    const hash = contentHash(content);
+    console.error(`--- ${filename} ---`);
+    // Step 1: Check for exact duplicates by hash
+    const exactMatch = existingNotes.find(n => n.metadata.content_hash === hash);
+    if (exactMatch) {
+        const key = exactMatch.metadata.upsert_key || `note-${exactMatch.id}`;
+        console.error(`This file is identical to "${key}" in Ledger.`);
+        console.error(`\nExisting note content:\n${exactMatch.content.slice(0, 500)}${exactMatch.content.length > 500 ? '\n...' : ''}\n`);
+        const skip = await confirm('Skip ingestion?');
+        if (skip) {
+            console.error(`Skipped ${filename}.`);
+            return;
+        }
+    }
+    // Step 2: Check for similar notes by embedding
+    if (!exactMatch) {
+        const similar = await searchNotes(config.supabase, config.openai, content, 0.5, 3);
+        if (similar.length > 0) {
+            const topMatch = similar[0];
+            const key = topMatch.metadata.upsert_key || `note-${topMatch.id}`;
+            console.error(`Similar note found: "${key}" (similarity: ${topMatch.similarity.toFixed(3)})`);
+            console.error(`\nExisting:\n${topMatch.content.slice(0, 500)}${topMatch.content.length > 500 ? '\n...' : ''}`);
+            console.error(`\nNew:\n${content.slice(0, 500)}${content.length > 500 ? '\n...' : ''}\n`);
+            const action = await choose('What would you like to do?', [
+                'Merge into existing',
+                'Replace existing',
+                'Add as new note',
+                'Skip',
+            ]);
+            switch (action) {
+                case 'Merge into existing': {
+                    const merged = `${topMatch.content}\n\n---\n\n${content}`;
+                    await updateAndHash(config, topMatch.id, merged);
+                    console.error(`Merged into "${key}".`);
+                    await askDeleteLocal(filePath, filename);
+                    return;
+                }
+                case 'Replace existing': {
+                    await updateAndHash(config, topMatch.id, content);
+                    console.error(`Replaced "${key}".`);
+                    await askDeleteLocal(filePath, filename);
+                    return;
+                }
+                case 'Skip': {
+                    console.error(`Skipped ${filename}.`);
+                    return;
+                }
+                // 'Add as new note' falls through to create below
+            }
+        }
+    }
+    // Step 3: No match or user chose "Add as new" — create new note
+    const shouldIngest = exactMatch ? true : await confirm(`Add "${filename}" to Ledger?`);
+    if (!shouldIngest) {
+        console.error(`Skipped ${filename}.`);
+        return;
+    }
+    const noteType = await choose('Note type:', [
+        'feedback',
+        'user-preference',
+        'architecture-decision',
+        'project-status',
+        'reference',
+        'event',
+        'error',
+        'general',
+    ]);
+    const { openai } = config;
+    const embeddingResponse = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: content,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const upsertKey = filename.replace(/\.md$/, '').replace(/_/g, '-');
+    const { data, error } = await config.supabase
+        .from('notes')
+        .insert({
+        content,
+        metadata: {
+            type: noteType,
+            agent: 'ledger-ingest',
+            upsert_key: upsertKey,
+            local_file: filename,
+            content_hash: hash,
+            local_cache: true,
+        },
+        embedding,
+    })
+        .select('id')
+        .single();
+    if (error) {
+        console.error(`Error adding note: ${error.message}`);
+        return;
+    }
+    console.error(`Added "${filename}" → Ledger (note ${data.id})`);
+    await askDeleteLocal(filePath, filename);
+}
+async function updateAndHash(config, noteId, content) {
+    const { openai, supabase } = config;
+    const embeddingResponse = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: content,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const hash = contentHash(content);
+    const { data: note } = await supabase
+        .from('notes')
+        .select('metadata')
+        .eq('id', noteId)
+        .single();
+    const metadata = {
+        ...(note?.metadata || {}),
+        content_hash: hash,
+    };
+    await supabase
+        .from('notes')
+        .update({ content, embedding, metadata, updated_at: new Date().toISOString() })
+        .eq('id', noteId);
+}
+async function askDeleteLocal(filePath, filename) {
+    const shouldDelete = await confirm(`Delete local file "${filename}"?`);
+    if (shouldDelete) {
+        unlinkSync(filePath);
+        console.error(`Deleted ${filename}.`);
+    }
+    else {
+        console.error(`Kept ${filename} locally.`);
+    }
+}
+async function autoIngestFile(config, filePath, existingNotes) {
+    if (!existsSync(filePath))
+        return;
+    const filename = basename(filePath);
+    const content = readFileSync(filePath, 'utf-8').trim();
+    const hash = contentHash(content);
+    // Check for exact duplicate — skip silently if identical
+    const exactMatch = existingNotes.find(n => n.metadata.content_hash === hash);
+    if (exactMatch) {
+        unlinkSync(filePath);
+        console.error(`AUTO: ${filename} — identical to existing note, deleted local.`);
+        return;
+    }
+    // Infer type from filename
+    let noteType = 'general';
+    if (filename.startsWith('feedback_'))
+        noteType = 'feedback';
+    else if (filename.startsWith('user_'))
+        noteType = 'user-preference';
+    else if (filename.startsWith('project_'))
+        noteType = 'project-status';
+    else if (filename.startsWith('reference_'))
+        noteType = 'reference';
+    const embeddingResponse = await config.openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: content,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const upsertKey = filename.replace(/\.md$/, '').replace(/_/g, '-');
+    const { data, error } = await config.supabase
+        .from('notes')
+        .insert({
+        content,
+        metadata: {
+            type: noteType,
+            agent: 'ledger-auto-ingest',
+            upsert_key: upsertKey,
+            local_file: filename,
+            content_hash: hash,
+            local_cache: true,
+        },
+        embedding,
+    })
+        .select('id')
+        .single();
+    if (error) {
+        console.error(`AUTO: Error ingesting ${filename}: ${error.message}`);
+        return;
+    }
+    unlinkSync(filePath);
+    console.error(`AUTO: ${filename} → Ledger (note ${data.id}), deleted local.`);
+}

package/dist/commands/init.js

@@ -0,0 +1,142 @@
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { createClient } from '@supabase/supabase-js';
+import OpenAI from 'openai';
+import { ask, askMasked, confirm } from '../lib/prompt.js';
+import { getLedgerDir, loadConfigFile, getDefaultConfig } from '../lib/config.js';
+import { getMigrationFiles, readMigration } from '../lib/migrate.js';
+import { enableBackupCron } from './backup.js';
+export async function init() {
+    const ledgerDir = getLedgerDir();
+    const envPath = resolve(ledgerDir, '.env');
+    const configPath = resolve(ledgerDir, 'config.json');
+    console.error('Welcome to Ledger.\n');
+    mkdirSync(ledgerDir, { recursive: true });
+    let supabaseUrl = '';
+    let supabaseKey = '';
+    let openaiKey = '';
+    // Step 1: Check existing credentials
+    if (existsSync(envPath)) {
+        const overwrite = await confirm('Existing credentials found. Overwrite?');
+        if (!overwrite) {
+            console.error('Keeping existing credentials.\n');
+            const envContent = readFileSync(envPath, 'utf-8');
+            for (const line of envContent.split('\n')) {
+                const eqIndex = line.indexOf('=');
+                if (eqIndex === -1)
+                    continue;
+                const key = line.slice(0, eqIndex);
+                const value = line.slice(eqIndex + 1);
+                if (key === 'SUPABASE_URL')
+                    supabaseUrl = value;
+                if (key === 'SUPABASE_SERVICE_ROLE_KEY')
+                    supabaseKey = value;
+                if (key === 'OPENAI_API_KEY')
+                    openaiKey = value;
+            }
+        }
+    }
+    // Step 2: Get credentials
+    if (!supabaseUrl) {
+        const hasProject = await confirm('Do you have a Supabase project?');
+        if (!hasProject) {
+            console.error(`
+To create a Supabase project:
+  1. Go to https://supabase.com and create a free account
+  2. Create a new project (any name, any region)
+  3. Enable pgvector: Database > Extensions > search "vector" > Enable
+  4. Go to Settings > API and copy:
+     - Project URL
+     - service_role key (under "Project API keys")
+  5. Get an OpenAI API key from https://platform.openai.com/api-keys
+`);
+            await ask('Press Enter when ready...');
+        }
+        supabaseUrl = await ask('Supabase URL: ');
+        supabaseKey = await askMasked('Service Role Key: ');
+        openaiKey = await askMasked('OpenAI API Key (required for embeddings, even with Claude): ');
+        const envContent = [
+            `SUPABASE_URL=${supabaseUrl}`,
+            `SUPABASE_SERVICE_ROLE_KEY=${supabaseKey}`,
+            `OPENAI_API_KEY=${openaiKey}`,
+            '',
+        ].join('\n');
+        writeFileSync(envPath, envContent, { mode: 0o600 });
+        console.error('Credentials saved to ~/.ledger/.env\n');
+    }
+    // Step 3: Write/merge config.json
+    const existing = loadConfigFile();
+    const defaults = getDefaultConfig();
+    const merged = {
+        ...defaults,
+        ...existing,
+        hooks: { ...defaults.hooks, ...existing.hooks },
+    };
+    writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n');
+    console.error('Config saved to ~/.ledger/config.json\n');
+    // Step 4: Verify Supabase connection
+    console.error('Connecting to Supabase...');
+    const supabase = createClient(supabaseUrl, supabaseKey);
+    const { error: connError } = await supabase
+        .from('schema_migrations')
+        .select('version')
+        .limit(1);
+    const isNew = connError?.code === '42P01'; // relation does not exist
+    if (connError && !isNew) {
+        console.error(`Connection error: ${connError.message}`);
+        console.error('Check your Supabase URL and service role key.');
+        process.exit(1);
+    }
+    console.error('Connected.\n');
+    // Step 5: Validate OpenAI key
+    console.error('Validating OpenAI key...');
+    try {
+        const openai = new OpenAI({ apiKey: openaiKey });
+        await openai.embeddings.create({ model: 'text-embedding-3-small', input: 'test' });
+        console.error('OpenAI key valid.\n');
+    }
+    catch (e) {
+        console.error(`OpenAI key invalid: ${e.message}`);
+        console.error('Check your OpenAI API key.');
+        process.exit(1);
+    }
+    // Step 6: Run migrations or confirm existing
+    if (isNew) {
+        console.error('New database detected. Setting up schema...\n');
+        const files = getMigrationFiles();
+        const allSql = files.map(f => {
+            const sql = readMigration(f);
+            return `-- ${f}\n${sql}`;
+        }).join('\n\n');
+        console.error('Run the following SQL in Supabase Dashboard > SQL Editor:\n');
+        console.error('='.repeat(60));
+        console.error(allSql);
+        console.error('='.repeat(60));
+        console.error('');
+        await ask('Press Enter after running the SQL...');
+        // Verify
+        const { error: verifyError } = await supabase
+            .from('notes')
+            .select('id')
+            .limit(1);
+        if (verifyError) {
+            console.error('Notes table not found. Make sure you ran all the SQL above.');
+            process.exit(1);
+        }
+        console.error('Schema verified.\n');
+    }
+    else {
+        const { count } = await supabase
+            .from('notes')
+            .select('*', { count: 'exact', head: true });
+        console.error(`Found existing Ledger with ${count ?? 0} notes.\n`);
+    }
+    // Step 7: Offer daily backup
+    const wantBackup = await confirm('Enable daily local backup? (Saves all notes to ~/.ledger/backups/ at 1am)');
+    if (wantBackup) {
+        enableBackupCron();
+    }
+    console.error('\nInit complete.');
+    console.error('Run `ledger setup <platform>` to connect an agent.');
+    console.error('Platforms: claude-code, openclaw, chatgpt');
+}

package/dist/commands/onboard.js

@@ -0,0 +1,190 @@
+import { getLedgerDir } from '../lib/config.js';
+import { fetchCachedNotes } from '../lib/notes.js';
+import { contentHash } from '../lib/hash.js';
+import { ask, confirm, choose } from '../lib/prompt.js';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+// --- Communication Presets ---
+const COMM_PRESETS = {
+    'Direct': `- Concise by default, thorough only when the content demands it
+- Structured outputs: headers, bullets, tables over prose
+- No sycophancy: no "Great question!", no filler. Agreement means actual agreement.
+- No emojis unless explicitly asked
+- Scope control: do what was asked, don't gold-plate
+- Don't narrate work while doing it. Do the thing, then report.
+- Pushback welcome: disagree when something is wrong, bring reasoning`,
+    'Educational': `- Explain concepts as you go, provide context for decisions
+- Step-by-step walkthroughs for complex tasks
+- Use analogies and plain language for unfamiliar topics
+- Structured outputs with headers and bullets
+- Be thorough — understanding matters more than speed
+- No sycophancy: keep it honest and grounded`,
+    'Collaborative': `- Ask before acting on anything non-trivial
+- Present options with trade-offs, recommend but let user decide
+- Discuss architecture and design before implementation
+- Check in at milestones, don't go heads-down for too long
+- Structured outputs with clear decision points
+- No sycophancy: honest assessment over agreeableness`,
+};
+// --- Default Rules (always included) ---
+const DEFAULT_SECURITY_RULES = `- Never read .env files or any files containing secrets/credentials
+- Never read SSH keys, certificates (.pem, .key, .p12), AWS credentials, or auth tokens
+- Check file existence with 'test -f' or 'wc -l', never by reading content
+- Never expose API keys, tokens, or passwords in any output`;
+const DEFAULT_KNOWLEDGE_RULES = `- Ledger is the source of truth for all knowledge
+- Local files are cache — update Ledger first, then local
+- Use ledger CLI for syncing between Ledger and local files`;
+// --- Onboard ---
+export async function onboard(config) {
+    const envPath = resolve(getLedgerDir(), '.env');
+    if (!existsSync(envPath)) {
+        console.error('Ledger not initialized. Run `ledger init` first.');
+        process.exit(1);
+    }
+    // Check if persona already exists
+    const existing = await fetchCachedNotes(config.supabase);
+    const hasProfile = existing.some(n => n.metadata.type === 'user-preference');
+    const hasFeedback = existing.some(n => n.metadata.type === 'feedback');
+    if (hasProfile || hasFeedback) {
+        const proceed = await confirm('Persona notes already exist in Ledger. Run onboarding again? (will add, not replace)');
+        if (!proceed) {
+            console.error('Cancelled.');
+            return;
+        }
+    }
+    console.error('\nLet\'s set up your AI persona.\n');
+    // 1. Name
+    const name = await ask('What\'s your name? ');
+    // 2. Role
+    const role = await ask('What do you do? (e.g. Software Engineer, Student, Designer) ');
+    // 3. Communication style
+    const commStyle = await choose('How should the AI communicate with you?', [
+        'Direct — concise, no filler, structured',
+        'Educational — explain as you go, step by step',
+        'Collaborative — ask before acting, discuss trade-offs',
+        'Custom — define your own rules later',
+    ]);
+    // 4. Technical level
+    const techLevel = await choose('Technical skill level?', [
+        'Beginner — new to coding, explain everything',
+        'Intermediate — comfortable coding, explain advanced concepts',
+        'Senior — experienced, skip basics, focus on architecture',
+    ]);
+    // 5. Languages/frameworks
+    const languages = await ask('Languages and frameworks you use? (comma-separated, or "skip") ');
+    // 6. Learning goals (optional)
+    const wantGoals = await confirm('Want to add learning goals?');
+    let goals = '';
+    if (wantGoals) {
+        goals = await ask('What are you learning or working toward? ');
+    }
+    // --- Create notes ---
+    console.error('\nCreating persona in Ledger...\n');
+    // User profile
+    const profileContent = [
+        `## Role`,
+        role,
+        '',
+        `## Technical Level`,
+        techLevel.split(' — ')[0],
+        '',
+    ];
+    if (languages && languages.toLowerCase() !== 'skip') {
+        profileContent.push('## Technical Skills', languages, '');
+    }
+    if (goals) {
+        profileContent.push('## Learning Goals', goals, '');
+    }
+    await createNote(config, {
+        content: profileContent.join('\n'),
+        type: 'user-preference',
+        upsertKey: 'user-profile',
+        localFile: 'user_profile.md',
+        label: `${name}'s profile`,
+    });
+    // Communication style
+    let commContent;
+    if (commStyle.startsWith('Custom')) {
+        commContent = '- Define your communication preferences here\n- Edit this note to customize';
+    }
+    else {
+        const presetKey = commStyle.split(' — ')[0];
+        commContent = COMM_PRESETS[presetKey] || COMM_PRESETS['Direct'];
+    }
+    await createNote(config, {
+        content: commContent,
+        type: 'feedback',
+        upsertKey: 'feedback-communication-style',
+        localFile: 'feedback_communication_style.md',
+        label: 'communication style',
+    });
+    // Technical level as working style
+    const levelDescriptions = {
+        'Beginner': '- Explain all concepts in plain language with analogies\n- Step-by-step walkthroughs\n- Don\'t assume familiarity with tools or syntax',
+        'Intermediate': '- Explain advanced concepts, skip basics\n- Provide context for architectural decisions\n- Assume familiarity with common tools and patterns',
+        'Senior': '- Skip explanations unless asked\n- Focus on architecture, trade-offs, edge cases\n- Assume deep familiarity with tools and patterns',
+    };
+    const levelKey = techLevel.split(' — ')[0];
+    await createNote(config, {
+        content: levelDescriptions[levelKey] || levelDescriptions['Intermediate'],
+        type: 'user-preference',
+        upsertKey: 'user-working-style',
+        localFile: 'user_working_style.md',
+        label: 'working style',
+    });
+    // Default security rules (always)
+    await createNote(config, {
+        content: DEFAULT_SECURITY_RULES,
+        type: 'feedback',
+        upsertKey: 'feedback-no-read-env',
+        localFile: 'feedback_no_read_env.md',
+        label: 'security rules',
+    });
+    // Default knowledge rules (always)
+    await createNote(config, {
+        content: DEFAULT_KNOWLEDGE_RULES,
+        type: 'feedback',
+        upsertKey: 'feedback-knowledge-system',
+        localFile: 'feedback_knowledge_system.md',
+        label: 'knowledge system rules',
+    });
+    console.error('\nPersona created. Run `ledger pull` to sync locally, or `ledger setup <platform>` if not done yet.');
+}
+async function createNote(config, input) {
+    const { content, type, upsertKey, localFile, label } = input;
+    // Check for existing note with same upsert_key
+    const { data: existing } = await config.supabase
+        .from('notes')
+        .select('id')
+        .eq('metadata->>upsert_key', upsertKey)
+        .limit(1)
+        .single();
+    if (existing) {
+        console.error(`  skip "${label}" (already exists)`);
+        return;
+    }
+    const embeddingResponse = await config.openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: content,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const { error } = await config.supabase
+        .from('notes')
+        .insert({
+        content,
+        metadata: {
+            type,
+            agent: 'ledger-onboard',
+            upsert_key: upsertKey,
+            local_file: localFile,
+            local_cache: true,
+            content_hash: contentHash(content),
+        },
+        embedding,
+    });
+    if (error) {
+        console.error(`  error creating "${label}": ${error.message}`);
+        return;
+    }
+    console.error(`  created "${label}"`);
+}

package/dist/commands/pull.js

@@ -0,0 +1,75 @@
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { fetchCachedNotes, updateNoteHash } from '../lib/notes.js';
+import { contentHash } from '../lib/hash.js';
+import { generateClaudeMd, generateMemoryMd } from '../lib/generators.js';
+export async function pull(config, options) {
+    const { quiet, force } = options;
+    const notes = await fetchCachedNotes(config.supabase);
+    if (notes.length === 0) {
+        if (!quiet)
+            console.error('No cached notes found in Ledger.');
+        return;
+    }
+    mkdirSync(config.memoryDir, { recursive: true });
+    const writtenFiles = [];
+    const conflicts = [];
+    for (const note of notes) {
+        const localFile = note.metadata.local_file;
+        if (!localFile)
+            continue;
+        const filePath = resolve(config.memoryDir, localFile);
+        const ledgerContent = note.content;
+        const ledgerHash = contentHash(ledgerContent);
+        const storedHash = note.metadata.content_hash;
+        if (!force && existsSync(filePath)) {
+            const localRaw = readFileSync(filePath, 'utf-8').trim();
+            const localHash = contentHash(localRaw);
+            // If local content differs from what we last wrote (stored hash), it's been modified
+            if (storedHash && localHash !== storedHash) {
+                // If Ledger also changed, it's a conflict
+                if (ledgerHash !== storedHash) {
+                    conflicts.push(localFile);
+                    console.log(`CONFLICT:${localFile}`);
+                    continue;
+                }
+                // Only local changed — don't overwrite
+                conflicts.push(localFile);
+                console.log(`CONFLICT:${localFile}`);
+                continue;
+            }
+        }
+        writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+        writtenFiles.push(localFile);
+        // Store the hash of what we wrote so check can detect local modifications
+        if (!storedHash || storedHash !== ledgerHash) {
+            await updateNoteHash(config.supabase, note.id, ledgerHash);
+        }
+        if (!quiet)
+            console.error(`  wrote ${localFile}`);
+    }
+    writeGeneratedFiles(config, notes, writtenFiles, conflicts, force, quiet);
+    if (!quiet) {
+        console.error(`\nPull complete: ${writtenFiles.length} written, ${conflicts.length} conflicts`);
+    }
+}
+function writeGeneratedFiles(config, notes, writtenFiles, conflicts, force, quiet) {
+    const allLocalFiles = [...writtenFiles, ...conflicts];
+    const memoryPath = resolve(config.memoryDir, 'MEMORY.md');
+    writeFileSync(memoryPath, generateMemoryMd(allLocalFiles), 'utf-8');
+    if (!quiet)
+        console.error('  wrote MEMORY.md');
+    const feedbackNotes = notes.filter(n => n.metadata.type === 'feedback');
+    const newClaudeMd = generateClaudeMd(feedbackNotes);
+    // Protect user-authored CLAUDE.md — only overwrite if it was generated by Ledger
+    if (existsSync(config.claudeMdPath)) {
+        const existing = readFileSync(config.claudeMdPath, 'utf-8');
+        if (!existing.startsWith('# Global Rules') && !force) {
+            console.log('CONFLICT:CLAUDE.md (exists with non-Ledger content, use --force to overwrite)');
+            return;
+        }
+    }
+    writeFileSync(config.claudeMdPath, newClaudeMd, 'utf-8');
+    if (!quiet)
+        console.error('  wrote ~/CLAUDE.md');
+}

package/dist/commands/push.js

@@ -0,0 +1,21 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve, basename } from 'path';
+import { findNoteByFile, updateNoteContent, updateNoteHash } from '../lib/notes.js';
+import { contentHash } from '../lib/hash.js';
+import { fatal, ExitCode } from '../lib/errors.js';
+export async function push(config, filePath) {
+    const absPath = resolve(filePath);
+    if (!existsSync(absPath)) {
+        fatal(`File not found: ${absPath}`, ExitCode.FILE_NOT_FOUND);
+    }
+    const filename = basename(absPath);
+    const content = readFileSync(absPath, 'utf-8').trim();
+    const existing = await findNoteByFile(config.supabase, filename);
+    if (!existing) {
+        fatal(`No Ledger note matching "${filename}" found. Add it via MCP first.`, ExitCode.NOTE_NOT_FOUND);
+    }
+    await updateNoteContent(config.supabase, config.openai, existing.id, content);
+    const hash = contentHash(content);
+    await updateNoteHash(config.supabase, existing.id, hash);
+    console.log(`Pushed ${filename} → Ledger (note ${existing.id})`);
+}