@aperdomoll90/ledger-ai 1.0.2 → 1.1.0

package/dist/commands/setup.js

@@ -1,10 +1,10 @@
-import { writeFileSync, readFileSync, copyFileSync, mkdirSync, existsSync, chmodSync } from 'fs';
+import { writeFileSync, readFileSync, copyFileSync, mkdirSync, existsSync, chmodSync, unlinkSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execFileSync } from 'child_process';
 import { homedir } from 'os';
 import { loadConfig, loadConfigFile, getLedgerDir } from '../lib/config.js';
-import { fetchCachedNotes } from '../lib/notes.js';
+import { fetchPersonaNotes } from '../lib/notes.js';
 import { generateClaudeMd } from '../lib/generators.js';
 import { ask } from '../lib/prompt.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -15,6 +15,90 @@ function verifyInit() {
         process.exit(1);
     }
 }
+/** Detect whether a platform is currently installed/configured. */
+export function detectPlatform(name) {
+    switch (name) {
+        case 'claude-code': {
+            try {
+                const output = execFileSync('claude', ['mcp', 'list'], { stdio: 'pipe', encoding: 'utf-8' });
+                const installed = output.toLowerCase().includes('ledger');
+                return { name, installed, detail: installed ? 'MCP registered' : 'Claude Code found, Ledger not registered' };
+            }
+            catch {
+                return { name, installed: false, detail: 'Claude Code CLI not found' };
+            }
+        }
+        case 'openclaw': {
+            // Check common locations for SOUL.md + USER.md
+            const configFile = loadConfigFile();
+            const openclawPath = configFile.openclawPath;
+            if (openclawPath && existsSync(resolve(openclawPath, 'SOUL.md')) && existsSync(resolve(openclawPath, 'USER.md'))) {
+                return { name, installed: true, detail: openclawPath };
+            }
+            return { name, installed: false };
+        }
+        case 'chatgpt': {
+            // ChatGPT has no persistent state — never detected as installed
+            return { name, installed: false, detail: 'No persistent state' };
+        }
+    }
+}
+// --- Uninstall functions ---
+/** Remove Ledger MCP registration, hooks, and settings entries for Claude Code. */
+export function uninstallClaudeCode() {
+    // 1. Remove MCP registration
+    try {
+        execFileSync('claude', ['mcp', 'remove', 'ledger', '-s', 'user'], { stdio: 'pipe' });
+        console.error('  Removed MCP registration.');
+    }
+    catch {
+        console.error('  MCP registration not found (already removed).');
+    }
+    // 2. Remove hook files
+    const claudeHooksDir = resolve(homedir(), '.claude/hooks');
+    const hookFiles = ['block-env.sh', 'post-write-ledger.sh', 'session-end-check.sh'];
+    for (const file of hookFiles) {
+        const hookPath = resolve(claudeHooksDir, file);
+        if (existsSync(hookPath)) {
+            unlinkSync(hookPath);
+            console.error(`  Removed ${file}`);
+        }
+    }
+    // 3. Remove Ledger hook entries from settings.json
+    const settingsPath = resolve(homedir(), '.claude/settings.json');
+    if (existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            if (settings.hooks) {
+                delete settings.hooks;
+                writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+                console.error('  Removed hook entries from settings.json');
+            }
+        }
+        catch {
+            // Settings parse error — leave as-is
+        }
+    }
+}
+/** Remove SOUL.md and USER.md from OpenClaw workspace. */
+export function uninstallOpenclaw(path) {
+    const configFile = loadConfigFile();
+    const targetPath = path || configFile.openclawPath;
+    if (!targetPath) {
+        console.error('  No OpenClaw workspace path configured.');
+        return;
+    }
+    const soulPath = resolve(targetPath, 'SOUL.md');
+    const userPath = resolve(targetPath, 'USER.md');
+    if (existsSync(soulPath)) {
+        unlinkSync(soulPath);
+        console.error('  Removed SOUL.md');
+    }
+    if (existsSync(userPath)) {
+        unlinkSync(userPath);
+        console.error('  Removed USER.md');
+    }
+}
 export async function setupClaudeCode() {
     verifyInit();
     const config = loadConfig();
@@ -102,7 +186,7 @@ export async function setupOpenclaw(path) {
         process.exit(1);
     }
     console.error(`Setting up OpenClaw at ${targetPath}...\n`);
-    const notes = await fetchCachedNotes(config.supabase);
+    const notes = await fetchPersonaNotes(config.supabase);
     const userNotes = notes.filter(n => n.metadata.type === 'user-preference');
     const feedbackNotes = notes.filter(n => n.metadata.type === 'feedback');
     // Generate SOUL.md (communication/behavior rules)
@@ -118,7 +202,7 @@ export async function setupOpenclaw(path) {
 export async function setupChatgpt() {
     verifyInit();
     const config = loadConfig();
-    const notes = await fetchCachedNotes(config.supabase);
+    const notes = await fetchPersonaNotes(config.supabase);
     const feedbackNotes = notes.filter(n => n.metadata.type === 'feedback');
     const prompt = generateClaudeMd(feedbackNotes);
     console.error('WARNING: This is a snapshot, not a live connection.');

package/dist/commands/sync.js

@@ -0,0 +1,206 @@
+import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync, readdirSync } from 'fs';
+import { resolve } from 'path';
+import { fetchPersonaNotes, updateNoteContent, updateNoteHash } from '../lib/notes.js';
+import { contentHash } from '../lib/hash.js';
+import { generateClaudeMd, generateMemoryMd } from '../lib/generators.js';
+import { confirm } from '../lib/prompt.js';
+export async function sync(config, options) {
+    const { quiet, force, dryRun } = options;
+    const notes = await fetchPersonaNotes(config.supabase);
+    const result = {
+        downloaded: [],
+        uploaded: [],
+        conflicts: [],
+        orphansRemoved: [],
+        skipped: [],
+    };
+    if (notes.length === 0) {
+        if (!quiet)
+            console.error('No persona notes found in Ledger.');
+        return result;
+    }
+    mkdirSync(config.memoryDir, { recursive: true });
+    const notesByFile = new Map();
+    for (const note of notes) {
+        const localFile = note.metadata.local_file;
+        if (localFile)
+            notesByFile.set(localFile, note);
+    }
+    // --- Phase 1: Process each persona note ---
+    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 (!existsSync(filePath)) {
+            // File missing locally → download from Ledger
+            if (dryRun) {
+                if (!quiet)
+                    console.error(`  ${localFile} — would download (missing locally)`);
+                result.downloaded.push(localFile);
+                continue;
+            }
+            writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+            if (!storedHash || storedHash !== ledgerHash) {
+                await updateNoteHash(config.supabase, note.id, ledgerHash);
+            }
+            result.downloaded.push(localFile);
+            if (!quiet)
+                console.error(`  ${localFile} — downloaded`);
+            continue;
+        }
+        // File exists locally — compare
+        const localRaw = readFileSync(filePath, 'utf-8').trim();
+        const localHash = contentHash(localRaw);
+        const localChanged = storedHash ? localHash !== storedHash : localHash !== ledgerHash;
+        const ledgerChanged = storedHash ? ledgerHash !== storedHash : false;
+        if (!localChanged && !ledgerChanged) {
+            // In sync — skip
+            result.skipped.push(localFile);
+            continue;
+        }
+        if (localChanged && !ledgerChanged) {
+            // Local modified, Ledger unchanged → push local to Ledger
+            if (dryRun) {
+                if (!quiet)
+                    console.error(`  ${localFile} — would upload (modified locally)`);
+                result.uploaded.push(localFile);
+                continue;
+            }
+            if (force) {
+                // --force means overwrite local with Ledger
+                writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+                result.downloaded.push(localFile);
+                if (!quiet)
+                    console.error(`  ${localFile} — overwritten with Ledger version (--force)`);
+                continue;
+            }
+            if (quiet) {
+                // In quiet mode (SessionStart hook), don't prompt — just flag it
+                console.log(`MODIFIED:${localFile}`);
+                result.conflicts.push(localFile);
+                continue;
+            }
+            // Interactive: ask user
+            console.error(`\n  ${localFile} — modified locally`);
+            const shouldPush = await confirm('  Upload local changes to Ledger?');
+            if (shouldPush) {
+                await updateNoteContent(config.supabase, config.openai, note.id, localRaw);
+                await updateNoteHash(config.supabase, note.id, localHash);
+                result.uploaded.push(localFile);
+                console.error(`  ${localFile} — uploaded to Ledger`);
+            }
+            else {
+                // Discard local, restore from Ledger
+                writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+                result.downloaded.push(localFile);
+                console.error(`  ${localFile} — restored from Ledger`);
+            }
+            continue;
+        }
+        if (!localChanged && ledgerChanged) {
+            // Ledger updated, local unchanged → download
+            if (dryRun) {
+                if (!quiet)
+                    console.error(`  ${localFile} — would download (updated in Ledger)`);
+                result.downloaded.push(localFile);
+                continue;
+            }
+            writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+            await updateNoteHash(config.supabase, note.id, ledgerHash);
+            result.downloaded.push(localFile);
+            if (!quiet)
+                console.error(`  ${localFile} — updated from Ledger`);
+            continue;
+        }
+        // Both changed — conflict
+        if (dryRun) {
+            if (!quiet)
+                console.error(`  ${localFile} — CONFLICT (both changed)`);
+            result.conflicts.push(localFile);
+            continue;
+        }
+        if (force) {
+            writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+            result.downloaded.push(localFile);
+            if (!quiet)
+                console.error(`  ${localFile} — overwritten with Ledger version (--force)`);
+            continue;
+        }
+        if (quiet) {
+            console.log(`CONFLICT:${localFile}`);
+            result.conflicts.push(localFile);
+            continue;
+        }
+        // Interactive: show conflict
+        console.error(`\n  ${localFile} — CONFLICT (both changed)`);
+        const keepLedger = await confirm('  Keep Ledger version? (no = keep local and upload)');
+        if (keepLedger) {
+            writeFileSync(filePath, `${ledgerContent}\n`, 'utf-8');
+            await updateNoteHash(config.supabase, note.id, ledgerHash);
+            result.downloaded.push(localFile);
+            console.error(`  ${localFile} — restored from Ledger`);
+        }
+        else {
+            await updateNoteContent(config.supabase, config.openai, note.id, localRaw);
+            await updateNoteHash(config.supabase, note.id, localHash);
+            result.uploaded.push(localFile);
+            console.error(`  ${localFile} — uploaded to Ledger`);
+        }
+    }
+    // --- Phase 2: Detect orphaned local files (in memory/ but not in Ledger) ---
+    const localFiles = readdirSync(config.memoryDir)
+        .filter(f => f.endsWith('.md') && f !== 'MEMORY.md');
+    for (const file of localFiles) {
+        if (!notesByFile.has(file)) {
+            if (dryRun) {
+                if (!quiet)
+                    console.error(`  ${file} — orphaned (not in Ledger, would remove)`);
+                result.orphansRemoved.push(file);
+                continue;
+            }
+            // Orphaned cache file — Ledger note was deleted, remove local
+            const filePath = resolve(config.memoryDir, file);
+            unlinkSync(filePath);
+            result.orphansRemoved.push(file);
+            if (!quiet)
+                console.error(`  ${file} — removed (no longer in Ledger)`);
+        }
+    }
+    // --- Phase 3: Regenerate MEMORY.md and CLAUDE.md ---
+    if (!dryRun) {
+        const allLocalFiles = [...result.downloaded, ...result.uploaded, ...result.skipped, ...result.conflicts];
+        const memoryPath = resolve(config.memoryDir, 'MEMORY.md');
+        writeFileSync(memoryPath, generateMemoryMd(allLocalFiles), 'utf-8');
+        const feedbackNotes = notes.filter(n => n.metadata.type === 'feedback');
+        const newClaudeMd = generateClaudeMd(feedbackNotes);
+        if (existsSync(config.claudeMdPath)) {
+            const existing = readFileSync(config.claudeMdPath, 'utf-8');
+            if (existing.startsWith('# Global Rules') || force) {
+                writeFileSync(config.claudeMdPath, newClaudeMd, 'utf-8');
+                if (!quiet)
+                    console.error('  wrote ~/CLAUDE.md');
+            }
+        }
+        else {
+            writeFileSync(config.claudeMdPath, newClaudeMd, 'utf-8');
+            if (!quiet)
+                console.error('  wrote ~/CLAUDE.md');
+        }
+    }
+    // --- Summary ---
+    if (!quiet) {
+        const parts = [
+            result.downloaded.length > 0 ? `${result.downloaded.length} downloaded` : null,
+            result.uploaded.length > 0 ? `${result.uploaded.length} uploaded` : null,
+            result.conflicts.length > 0 ? `${result.conflicts.length} conflicts` : null,
+            result.orphansRemoved.length > 0 ? `${result.orphansRemoved.length} orphans removed` : null,
+            result.skipped.length > 0 ? `${result.skipped.length} in sync` : null,
+        ].filter(Boolean).join(', ');
+        console.error(`\nSync complete: ${parts || 'nothing to do'}`);
+    }
+    return result;
+}

package/dist/commands/tag.js

@@ -0,0 +1,20 @@
+import { opUpdateMetadata } from '../lib/notes.js';
+export async function tag(config, id, options) {
+    const metadata = {};
+    if (options.description)
+        metadata.description = options.description;
+    if (options.project)
+        metadata.project = options.project;
+    if (options.scope)
+        metadata.scope = options.scope;
+    if (Object.keys(metadata).length === 0) {
+        console.error('No metadata fields provided. Use --description, --project, or --scope.');
+        process.exit(1);
+    }
+    const result = await opUpdateMetadata({ supabase: config.supabase, openai: config.openai }, id, metadata);
+    if (result.status === 'error') {
+        console.error(result.message);
+        process.exit(1);
+    }
+    console.error(result.message);
+}

package/dist/commands/update.js

@@ -0,0 +1,22 @@
+import { opUpdateNote } from '../lib/notes.js';
+import { confirm } from '../lib/prompt.js';
+export async function update(config, id, content, options) {
+    const clients = { supabase: config.supabase, openai: config.openai };
+    // First call: show confirmation
+    const preview = await opUpdateNote(clients, id, content, options.metadata, false);
+    if (preview.status === 'error') {
+        console.error(preview.message);
+        process.exit(1);
+    }
+    console.error(preview.message);
+    const proceed = await confirm('\nProceed with update?');
+    if (!proceed) {
+        console.error('Cancelled.');
+        return;
+    }
+    // Second call: execute
+    const result = await opUpdateNote(clients, id, content, options.metadata, true);
+    console.error(result.message);
+    if (result.status === 'error')
+        process.exit(1);
+}