@aperdomoll90/ledger-ai 1.3.0 → 1.4.2

package/dist/lib/generators.js

@@ -1,4 +1,46 @@
-// --- CLAUDE.md Section Mapping ---
+/**
+ * Generate MEMORY.md as a search guide (v2).
+ * NOT a file index — tells agents what knowledge domains exist and when to search.
+ */
+export function generateMemoryMd(autoLoadFiles) {
+    const lines = [
+        '# What I Know About You',
+        '',
+        '## Auto-loaded (always in context)',
+        '',
+    ];
+    if (autoLoadFiles.length > 0) {
+        for (const f of autoLoadFiles) {
+            lines.push(`- [${f}](${f})`);
+        }
+    }
+    else {
+        lines.push('- Personality, behavioral rules, preferences — loaded from Ledger');
+    }
+    lines.push('');
+    lines.push('## Search Ledger when needed');
+    lines.push('');
+    lines.push('- **System:** hooks, plugin configs, sync rules — `search_notes` with domain: system');
+    lines.push('- **Workspace:** dashboards, device registry, dev environment — `search_notes` with domain: workspace');
+    lines.push('- **Projects:** architecture, status, errors, events — `search_notes` with project name or domain: project');
+    lines.push('- **Skills:** eval results, test cases — `search_notes` with skill name or type: skill');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Generate CLAUDE.md. In v2, prefers the claude-md note stored as a complete document.
+ * Falls back to legacy generation from feedback notes if no claude-md note exists.
+ * @deprecated v2 stores CLAUDE.md as a complete document (type: claude-md). This fallback will be removed.
+ */
+export function generateClaudeMd(notes) {
+    const claudeMdNote = notes.find(n => n.metadata.type === 'claude-md' ||
+        n.metadata.upsert_key === 'claude-md-backup');
+    if (claudeMdNote) {
+        return claudeMdNote.content;
+    }
+    return legacyGenerateClaudeMd(notes);
+}
+// --- Legacy helpers (pre-v2) ---
 const SECTION_MAP = {
     'Security': ['feedback-no-read-env'],
     'Coding Conventions': ['feedback-coding-conventions'],
@@ -10,7 +52,6 @@ const SECTION_MAP = {
     ],
     'Communication': ['feedback-communication-style'],
 };
-// --- Helpers ---
 function extractBulletPoints(content) {
     const lines = content.split('\n');
     const bullets = [];
@@ -35,8 +76,7 @@ function extractBulletPoints(content) {
     }
     return bullets.join('\n');
 }
-// --- Generators ---
-export function generateClaudeMd(notes) {
+function legacyGenerateClaudeMd(notes) {
     const notesByKey = new Map();
     for (const note of notes) {
         const key = note.metadata.upsert_key;
@@ -72,44 +112,3 @@ export function generateClaudeMd(notes) {
     }
     return sections.join('\n') + '\n';
 }
-export function generateMemoryMd(files) {
-    const userFiles = [];
-    const feedbackFiles = [];
-    const projectFiles = [];
-    for (const file of files) {
-        if (file.startsWith('user_'))
-            userFiles.push(file);
-        else if (file.startsWith('feedback_'))
-            feedbackFiles.push(file);
-        else if (file.startsWith('project_'))
-            projectFiles.push(file);
-    }
-    const lines = [
-        '# Memory Index',
-        '',
-        'Local cache files auto-loaded into Claude Code context. Source of truth is Ledger.',
-        '',
-    ];
-    if (userFiles.length > 0) {
-        lines.push('## User Profile');
-        for (const f of userFiles)
-            lines.push(`- [${f}](${f})`);
-        lines.push('');
-    }
-    if (feedbackFiles.length > 0) {
-        lines.push('## Feedback (Behavioral Rules)');
-        for (const f of feedbackFiles)
-            lines.push(`- [${f}](${f})`);
-        lines.push('');
-    }
-    if (projectFiles.length > 0) {
-        lines.push('## Project Status');
-        for (const f of projectFiles)
-            lines.push(`- [${f}](${f})`);
-        lines.push('');
-    }
-    lines.push('## Not Auto-Loaded (Search Ledger)');
-    lines.push('Architecture, references, project details, events, errors — all in Ledger, search on demand.');
-    lines.push('');
-    return lines.join('\n');
-}

package/dist/lib/hunter-db.js

@@ -0,0 +1,235 @@
+import { isValidStatus } from './hunter-types.js';
+export function buildInsertRow(listing, track) {
+    return {
+        url: listing.url,
+        title: listing.title,
+        raw_description: listing.description,
+        source: listing.source,
+        track,
+        score: null,
+        status: 'new',
+    };
+}
+export function buildStatusUpdate(status) {
+    if (!isValidStatus(status)) {
+        throw new Error(`Invalid status: ${status}`);
+    }
+    return {
+        status,
+        status_changed_at: new Date().toISOString(),
+    };
+}
+export function getScoreThreshold(score) {
+    if (score >= 80)
+        return 'apply';
+    if (score >= 60)
+        return 'apply';
+    if (score >= 40)
+        return 'ask';
+    return 'skip';
+}
+export function buildAnalyticsRow(opportunities, periodStart, periodEnd) {
+    const freelance = opportunities.filter(o => o.track === 'freelance');
+    const employment = opportunities.filter(o => o.track === 'employment');
+    const scored = opportunities.filter(o => o.score !== null);
+    const applied = opportunities.filter(o => o.status === 'applied');
+    const won = opportunities.filter(o => o.status === 'won');
+    const lost = opportunities.filter(o => o.status === 'lost');
+    const rejectReasons = {};
+    for (const opp of opportunities) {
+        if (opp.reject_reasons) {
+            for (const reason of opp.reject_reasons) {
+                rejectReasons[reason] = (rejectReasons[reason] || 0) + 1;
+            }
+        }
+    }
+    const skills = {};
+    for (const opp of opportunities) {
+        if (opp.key_requirements) {
+            for (const skill of opp.key_requirements) {
+                skills[skill] = (skills[skill] || 0) + 1;
+            }
+        }
+    }
+    const avgByTrack = {};
+    for (const track of ['freelance', 'employment']) {
+        const trackScored = scored.filter(o => o.track === track);
+        if (trackScored.length > 0) {
+            const sum = trackScored.reduce((acc, o) => acc + (o.score ?? 0), 0);
+            avgByTrack[track] = Math.round(sum / trackScored.length);
+        }
+    }
+    return {
+        period_start: periodStart,
+        period_end: periodEnd,
+        total_found: opportunities.length,
+        freelance_count: freelance.length,
+        employment_count: employment.length,
+        score_80_plus: scored.filter(o => (o.score ?? 0) >= 80).length,
+        score_60_79: scored.filter(o => (o.score ?? 0) >= 60 && (o.score ?? 0) < 80).length,
+        score_40_59: scored.filter(o => (o.score ?? 0) >= 40 && (o.score ?? 0) < 60).length,
+        score_below_40: scored.filter(o => (o.score ?? 0) < 40).length,
+        applied_count: applied.length,
+        won_count: won.length,
+        lost_count: lost.length,
+        apply_rate: opportunities.length > 0 ? Math.round((applied.length / opportunities.length) * 100) / 100 : null,
+        win_rate: applied.length > 0 ? Math.round((won.length / applied.length) * 100) / 100 : null,
+        top_reject_reasons: rejectReasons,
+        top_skills_demanded: skills,
+        avg_score_by_track: avgByTrack,
+        compensation_ranges: null,
+    };
+}
+// --- Supabase Operations ---
+export async function insertRawListings(supabase, listings, track) {
+    let inserted = 0;
+    let skipped = 0;
+    for (const listing of listings) {
+        const row = buildInsertRow(listing, track);
+        const { error } = await supabase
+            .from('opportunities')
+            .upsert(row, { onConflict: 'url', ignoreDuplicates: true });
+        if (error) {
+            skipped++;
+        }
+        else {
+            inserted++;
+        }
+    }
+    return { inserted, skipped };
+}
+export async function getUnscoredOpportunities(supabase) {
+    const { data, error } = await supabase
+        .from('opportunities')
+        .select('*')
+        .is('score', null)
+        .order('created_at', { ascending: true });
+    if (error)
+        throw new Error(`Failed to fetch unscored: ${error.message}`);
+    return (data ?? []);
+}
+export async function updateOpportunityScore(supabase, id, score, scoreBreakdown, recommendation, summary, keyRequirements, compensationRange, rejectReasons) {
+    const { error } = await supabase
+        .from('opportunities')
+        .update({
+        score,
+        score_breakdown: scoreBreakdown,
+        recommendation,
+        summary,
+        key_requirements: keyRequirements,
+        compensation_range: compensationRange,
+        reject_reasons: rejectReasons,
+        scored_at: new Date().toISOString(),
+    })
+        .eq('id', id);
+    if (error)
+        throw new Error(`Failed to update score: ${error.message}`);
+}
+export async function updateOpportunityStatus(supabase, id, status) {
+    const update = buildStatusUpdate(status);
+    const { error } = await supabase
+        .from('opportunities')
+        .update(update)
+        .eq('id', id);
+    if (error)
+        throw new Error(`Failed to update status: ${error.message}`);
+}
+export async function updateOpportunityNotes(supabase, id, notes) {
+    const { error } = await supabase
+        .from('opportunities')
+        .update({ notes })
+        .eq('id', id);
+    if (error)
+        throw new Error(`Failed to update notes: ${error.message}`);
+}
+export async function getOpportunities(supabase, options = {}) {
+    let query = supabase
+        .from('opportunities')
+        .select('*')
+        .order('score', { ascending: false, nullsFirst: false });
+    if (options.track)
+        query = query.eq('track', options.track);
+    if (options.status)
+        query = query.eq('status', options.status);
+    if (options.minScore)
+        query = query.gte('score', options.minScore);
+    if (options.limit)
+        query = query.limit(options.limit);
+    if (options.days) {
+        const since = new Date();
+        since.setDate(since.getDate() - options.days);
+        query = query.gte('created_at', since.toISOString());
+    }
+    const { data, error } = await query;
+    if (error)
+        throw new Error(`Failed to fetch opportunities: ${error.message}`);
+    return (data ?? []);
+}
+export async function getOpportunityById(supabase, id) {
+    const { data, error } = await supabase
+        .from('opportunities')
+        .select('*')
+        .eq('id', id)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Failed to fetch opportunity: ${error.message}`);
+    return data;
+}
+export async function getExistingUrls(supabase, urls) {
+    const existing = new Set();
+    // Batch to avoid oversized IN queries
+    const batchSize = 50;
+    for (let i = 0; i < urls.length; i += batchSize) {
+        const batch = urls.slice(i, i + batchSize);
+        const { data, error } = await supabase
+            .from('opportunities')
+            .select('url')
+            .in('url', batch);
+        if (error)
+            throw new Error(`Failed to check existing URLs: ${error.message}`);
+        for (const row of data ?? [])
+            existing.add(row.url);
+    }
+    return existing;
+}
+export async function getOpportunitiesForPeriod(supabase, start, end) {
+    const { data, error } = await supabase
+        .from('opportunities')
+        .select('*')
+        .gte('created_at', start)
+        .lte('created_at', end);
+    if (error)
+        throw new Error(`Failed to fetch period: ${error.message}`);
+    return (data ?? []);
+}
+export async function insertAnalytics(supabase, row) {
+    const { error } = await supabase
+        .from('hunt_analytics')
+        .upsert(row, { onConflict: 'period_start,period_end' });
+    if (error)
+        throw new Error(`Failed to insert analytics: ${error.message}`);
+}
+export async function getLatestAnalytics(supabase) {
+    const { data, error } = await supabase
+        .from('hunt_analytics')
+        .select('*')
+        .order('period_end', { ascending: false })
+        .limit(1)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Failed to fetch analytics: ${error.message}`);
+    return data;
+}
+export async function purgeOldRejected(supabase, days) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    const { data, error } = await supabase
+        .from('opportunities')
+        .delete()
+        .eq('status', 'rejected')
+        .lt('created_at', cutoff.toISOString())
+        .select('id');
+    if (error)
+        throw new Error(`Failed to purge: ${error.message}`);
+    return data?.length ?? 0;
+}

package/dist/lib/hunter-rss.js

@@ -0,0 +1,30 @@
+import Parser from 'rss-parser';
+const parser = new Parser();
+export function parseUpworkItem(item, sourceName) {
+    return {
+        url: item.link ?? '',
+        title: item.title ?? '',
+        description: item.contentSnippet || item.content || '',
+        source: sourceName,
+    };
+}
+export function deduplicateListings(listings, existingUrls) {
+    return listings.filter(l => !existingUrls.has(l.url));
+}
+export async function fetchFeed(feed) {
+    const result = await parser.parseURL(feed.url);
+    return (result.items ?? []).map(item => parseUpworkItem(item, feed.name));
+}
+export async function fetchAllFeeds(feeds) {
+    const all = [];
+    for (const feed of feeds) {
+        try {
+            const listings = await fetchFeed(feed);
+            all.push(...listings);
+        }
+        catch (err) {
+            console.error(`Failed to fetch feed "${feed.name}": ${err.message}`);
+        }
+    }
+    return all;
+}

package/dist/lib/hunter-scoring.js

@@ -0,0 +1,55 @@
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { isValidTrack, isValidRecommendation } from './hunter-types.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function loadSystemPrompt() {
+    const promptPath = resolve(__dirname, '../prompts/hunter-system.txt');
+    return readFileSync(promptPath, 'utf-8');
+}
+export function buildScoringPrompt(opportunityText) {
+    return `Score this opportunity:\n\n<opportunity>\n${opportunityText}\n</opportunity>`;
+}
+export function parseScoringResponse(response) {
+    let cleaned = response.trim();
+    const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (fenceMatch) {
+        cleaned = fenceMatch[1].trim();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(cleaned);
+    }
+    catch {
+        throw new Error(`Hunter returned invalid JSON: ${cleaned.slice(0, 200)}`);
+    }
+    const obj = parsed;
+    if (!obj.track || !isValidTrack(obj.track)) {
+        throw new Error(`Invalid or missing track: ${obj.track}`);
+    }
+    if (typeof obj.score !== 'number') {
+        throw new Error(`Invalid or missing score: ${obj.score}`);
+    }
+    if (!obj.recommendation || !isValidRecommendation(obj.recommendation)) {
+        throw new Error(`Invalid or missing recommendation: ${obj.recommendation}`);
+    }
+    if (typeof obj.summary !== 'string') {
+        throw new Error(`Invalid or missing summary`);
+    }
+    if (!Array.isArray(obj.key_requirements)) {
+        throw new Error(`Invalid or missing key_requirements`);
+    }
+    if (!obj.score_breakdown || typeof obj.score_breakdown !== 'object') {
+        throw new Error(`Invalid or missing score_breakdown`);
+    }
+    return {
+        track: obj.track,
+        score: obj.score,
+        recommendation: obj.recommendation,
+        summary: obj.summary,
+        key_requirements: obj.key_requirements,
+        compensation_range: obj.compensation_range ?? null,
+        reject_reasons: obj.reject_reasons ?? null,
+        score_breakdown: obj.score_breakdown,
+    };
+}

package/dist/lib/hunter-types.js

@@ -0,0 +1,36 @@
+// --- Constants ---
+export const TRACKS = ['freelance', 'employment'];
+export const STATUSES = [
+    'new', 'reviewed', 'applied', 'interviewing', 'won', 'lost', 'rejected',
+];
+export const RECOMMENDATIONS = ['apply', 'ask', 'skip'];
+export const REJECT_REASONS = [
+    'BUDGET_TOO_LOW',
+    'SCOPE_UNCLEAR',
+    'TIMELINE_UNREALISTIC',
+    'CLIENT_RED_FLAGS',
+    'SKILL_MISMATCH',
+    'PLATFORM_RISK',
+    'COMPLEXITY_EXCESSIVE',
+    'LOW_STRATEGIC_VALUE',
+    'SALARY_BELOW_MARKET',
+    'NO_REMOTE',
+    'STACK_MISMATCH',
+];
+// --- Validators ---
+export function isValidTrack(value) {
+    return TRACKS.includes(value);
+}
+export function isValidStatus(value) {
+    return STATUSES.includes(value);
+}
+export function isValidRecommendation(value) {
+    return RECOMMENDATIONS.includes(value);
+}
+export const DEFAULT_HUNTER_CONFIG = {
+    feeds: [],
+    cron_schedule: '*/30 8-23 * * *',
+    analytics_interval_days: 15,
+    purge_after_days: 90,
+    min_score_highlight: 80,
+};

package/dist/lib/lint-configs.js

@@ -61,6 +61,26 @@ export default [
   {
     rules: {
       'no-warning-comments': ['warn', { terms: ['TODO', 'FIXME', 'HACK'] }],
+      '@typescript-eslint/naming-convention': [
+        'error',
+        {
+          selector: 'interface',
+          format: ['PascalCase'],
+          prefix: ['I'],
+        },
+        {
+          selector: 'variable',
+          format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
+          filter: { regex: '^_$', match: false },
+          custom: { regex: '^[a-zA-Z]$', match: false },
+        },
+        {
+          selector: 'parameter',
+          format: ['camelCase'],
+          filter: { regex: '^_', match: false },
+          custom: { regex: '^[a-zA-Z]$', match: false },
+        },
+      ],
     },
   },
 ];

package/dist/lib/migrate.js

@@ -5,7 +5,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const MIGRATIONS_DIR = resolve(__dirname, '../migrations');
 export function getMigrationFiles() {
     return readdirSync(MIGRATIONS_DIR)
-        .filter(f => f.endsWith('.sql'))
+        .filter(file => file.endsWith('.sql'))
         .sort();
 }
 export function readMigration(filename) {
@@ -19,5 +19,5 @@ export async function getAppliedMigrations(supabase) {
         // Table doesn't exist yet — no migrations applied
         return new Set();
     }
-    return new Set((data || []).map(r => r.version));
+    return new Set((data || []).map(row => row.version));
 }