@aperdomoll90/ledger-ai 1.1.3 → 1.3.0

package/dist/commands/sync.js

@@ -1,6 +1,7 @@
 import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync, readdirSync } from 'fs';
 import { resolve } from 'path';
-import { fetchPersonaNotes, updateNoteContent, updateNoteHash } from '../lib/notes.js';
+import { loadConfigFile, saveConfigFile } from '../lib/config.js';
+import { fetchPersonaNotes, updateNoteContent, updateNoteHash, opAddNote } from '../lib/notes.js';
 import { contentHash } from '../lib/hash.js';
 import { generateClaudeMd, generateMemoryMd } from '../lib/generators.js';
 import { confirm } from '../lib/prompt.js';
@@ -20,6 +21,8 @@ export async function sync(config, options) {
         return result;
     }
     mkdirSync(config.memoryDir, { recursive: true });
+    // --- Phase 0: Sync type registry ---
+    await syncTypeRegistryPull(config, quiet, force, dryRun);
     const notesByFile = new Map();
     for (const note of notes) {
         const localFile = note.metadata.local_file;
@@ -191,6 +194,8 @@ export async function sync(config, options) {
                 console.error('  wrote ~/CLAUDE.md');
         }
     }
+    // --- Phase 3.5: Push type registry ---
+    await syncTypeRegistryPush(config, quiet, dryRun);
     // --- Summary ---
     if (!quiet) {
         const parts = [
@@ -204,3 +209,69 @@ export async function sync(config, options) {
     }
     return result;
 }
+export async function syncTypeRegistryPush(config, quiet, dryRun) {
+    const configFile = loadConfigFile();
+    const userTypes = configFile.types;
+    if (!userTypes || Object.keys(userTypes).length === 0) {
+        return; // Nothing to push
+    }
+    const content = JSON.stringify(userTypes, null, 2);
+    const clients = { supabase: config.supabase, openai: config.openai };
+    if (dryRun) {
+        if (!quiet)
+            console.error('  type-registry — would push to Ledger');
+        return;
+    }
+    await opAddNote(clients, content, 'system-rule', 'ledger-sync', {
+        upsert_key: 'system-rule-type-registry',
+        description: 'User-defined type registry overrides. Managed by ledger sync.',
+        delivery: 'persona',
+        scope: 'system',
+        interactive_skip: true,
+    }, true); // force: true to skip duplicate guard
+    if (!quiet)
+        console.error('  type-registry — pushed to Ledger');
+}
+export async function syncTypeRegistryPull(config, quiet, force, dryRun) {
+    const { data: note } = await config.supabase
+        .from('notes')
+        .select('content')
+        .eq('metadata->>upsert_key', 'system-rule-type-registry')
+        .limit(1)
+        .single();
+    if (!note)
+        return; // No remote type registry
+    let remoteTypes;
+    try {
+        remoteTypes = JSON.parse(note.content);
+    }
+    catch {
+        if (!quiet)
+            console.error('  type-registry — invalid JSON in remote note, skipping');
+        return;
+    }
+    const configFile = loadConfigFile();
+    const localTypes = configFile.types ?? {};
+    // Merge: local wins unless --force
+    const merged = force
+        ? { ...localTypes, ...remoteTypes }
+        : { ...remoteTypes, ...localTypes };
+    // Check if anything changed
+    const localJson = JSON.stringify(localTypes, Object.keys(localTypes).sort());
+    const mergedJson = JSON.stringify(merged, Object.keys(merged).sort());
+    if (localJson === mergedJson)
+        return; // No changes
+    if (dryRun) {
+        const newKeys = Object.keys(merged).filter(k => !(k in localTypes));
+        if (newKeys.length > 0 && !quiet) {
+            console.error(`  type-registry — would add: ${newKeys.map(k => `${k} (${merged[k]})`).join(', ')}`);
+        }
+        return;
+    }
+    configFile.types = merged;
+    saveConfigFile(configFile);
+    const newKeys = Object.keys(merged).filter(k => !(k in localTypes));
+    if (newKeys.length > 0 && !quiet) {
+        console.error(`  type-registry synced: added ${newKeys.map(k => `${k} (${merged[k]})`).join(', ')}`);
+    }
+}

package/dist/lib/config.js

@@ -3,7 +3,7 @@ import { createClient } from '@supabase/supabase-js';
 import OpenAI from 'openai';
 import { resolve } from 'path';
 import { homedir } from 'os';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { fatal, ExitCode } from './errors.js';
 // --- Defaults ---
 const LEDGER_DIR = resolve(homedir(), '.ledger');
@@ -28,6 +28,11 @@ export function loadConfigFile() {
     }
     return {};
 }
+export function saveConfigFile(config) {
+    const configPath = resolve(getLedgerDir(), 'config.json');
+    mkdirSync(getLedgerDir(), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
 export function getDefaultConfig() {
     return {
         memoryDir: DEFAULT_MEMORY_DIR,

package/dist/lib/lint-configs.js

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { resolve, join } from 'path';
+// --- Config Templates ---
+// Keep shared TS rules in sync between ESLINT_TS and ESLINT_TS_REACT
+export const ESLINT_TS = `import tseslint from 'typescript-eslint';
+import importPlugin from 'eslint-plugin-import';
+
+export default tseslint.config(
+  ...tseslint.configs.recommended,
+  {
+    plugins: {
+      import: importPlugin,
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'import/no-default-export': 'error',
+      'max-lines': ['warn', { max: 200, skipBlankLines: true, skipComments: true }],
+      'no-console': ['warn', { allow: ['error', 'warn'] }],
+    },
+  },
+);
+`;
+export const ESLINT_TS_REACT = `import tseslint from 'typescript-eslint';
+import reactPlugin from 'eslint-plugin-react';
+import jsxA11yPlugin from 'eslint-plugin-jsx-a11y';
+import importPlugin from 'eslint-plugin-import';
+
+export default tseslint.config(
+  ...tseslint.configs.recommended,
+  {
+    plugins: {
+      react: reactPlugin,
+      'jsx-a11y': jsxA11yPlugin,
+      import: importPlugin,
+    },
+    settings: {
+      react: { version: 'detect' },
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'react/button-has-type': 'error',
+      'import/no-default-export': 'error',
+      'jsx-a11y/anchor-is-valid': 'warn',
+      'jsx-a11y/click-events-have-key-events': 'warn',
+      'max-lines': ['warn', { max: 200, skipBlankLines: true, skipComments: true }],
+      'no-console': ['warn', { allow: ['error', 'warn'] }],
+    },
+  },
+);
+`;
+// Backwards compat alias
+export const ESLINT_UNIVERSAL = ESLINT_TS_REACT;
+export const ESLINT_PERSONAL = `import universalConfig from './eslint.config.js';
+
+export default [
+  ...universalConfig,
+  {
+    rules: {
+      'no-warning-comments': ['warn', { terms: ['TODO', 'FIXME', 'HACK'] }],
+    },
+  },
+];
+`;
+export const STYLELINT_UNIVERSAL = JSON.stringify({
+    extends: ['stylelint-config-standard-scss'],
+    rules: {
+        'unit-disallowed-list': ['vh', 'vw'],
+        'declaration-property-unit-allowed-list': {
+            padding: ['rem', '%'],
+            margin: ['rem', '%'],
+            gap: ['rem', '%'],
+            'border-width': ['px'],
+            'font-size': ['rem'],
+        },
+        'color-no-hex': [true, { severity: 'warning' }],
+        'declaration-no-important': true,
+        'declaration-block-no-duplicate-properties': true,
+        'shorthand-property-no-redundant-values': [true, { severity: 'warning' }],
+    },
+}, null, 2);
+export const STYLELINT_PERSONAL = JSON.stringify({
+    extends: ['./.stylelintrc.json'],
+    rules: {
+        'selector-class-pattern': [
+            '^c-[a-z][a-z0-9]*(__[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*)?$',
+            {
+                message: 'Class names must use BEM with c- prefix (e.g. c-block__element-modifier)',
+            },
+        ],
+        'unit-disallowed-list': ['vh', 'vw', 'dvh'],
+        'media-feature-name-disallowed-list': ['max-width'],
+        'max-nesting-depth': [3, { severity: 'warning' }],
+    },
+}, null, 2);
+function hasScssFiles(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry === 'node_modules')
+            continue;
+        const fullPath = join(dir, entry);
+        let stat;
+        try {
+            stat = statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            if (hasScssFiles(fullPath))
+                return true;
+        }
+        else if (entry.endsWith('.scss')) {
+            return true;
+        }
+    }
+    return false;
+}
+export function detectStack(projectDir) {
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    const tsConfigPath = resolve(projectDir, 'tsconfig.json');
+    const hasPackageJson = existsSync(packageJsonPath);
+    const hasTypeScript = existsSync(tsConfigPath);
+    let hasReact = false;
+    if (hasPackageJson) {
+        try {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            hasReact = 'react' in deps;
+        }
+        catch {
+            // leave hasReact false
+        }
+    }
+    const hasScss = hasScssFiles(projectDir);
+    return { hasPackageJson, hasTypeScript, hasReact, hasScss };
+}
+export function getConfigsForStack(stack, personal) {
+    const needsEslint = stack.hasTypeScript || stack.hasReact;
+    const needsStylelint = stack.hasScss;
+    const eslint = needsEslint
+        ? {
+            filename: personal ? 'eslint.config.personal.js' : 'eslint.config.js',
+            content: personal ? ESLINT_PERSONAL : (stack.hasReact ? ESLINT_TS_REACT : ESLINT_TS),
+        }
+        : null;
+    const stylelint = needsStylelint
+        ? {
+            filename: personal ? '.stylelintrc.personal.json' : '.stylelintrc.json',
+            content: personal ? STYLELINT_PERSONAL : STYLELINT_UNIVERSAL,
+        }
+        : null;
+    return { eslint, stylelint };
+}

package/dist/lib/notes.js

@@ -1,19 +1,60 @@
 import { randomUUID } from 'crypto';
 import { fatal, ExitCode } from './errors.js';
 import { contentHash } from './hash.js';
-import { loadConfigFile } from './config.js';
-const DELIVERY_BY_TYPE = {
+import { loadConfigFile, saveConfigFile } from './config.js';
+// --- Built-in Type Registry ---
+export const BUILTIN_TYPES = {
     'user-preference': 'persona',
-    'feedback': 'persona',
+    'persona-rule': 'persona',
+    'system-rule': 'persona',
+    'code-craft': 'persona',
     'architecture-decision': 'project',
     'project-status': 'project',
-    'error': 'project',
     'event': 'project',
+    'error': 'project',
     'reference': 'knowledge',
+    'knowledge-guide': 'knowledge',
     'general': 'knowledge',
 };
+const TYPE_ALIASES = {
+    'feedback': 'general',
+};
+function resolveTypeAlias(type) {
+    return TYPE_ALIASES[type] ?? type;
+}
+export function getTypeRegistry() {
+    const config = loadConfigFile();
+    return { ...BUILTIN_TYPES, ...(config.types ?? {}) };
+}
 export function inferDelivery(noteType) {
-    return DELIVERY_BY_TYPE[noteType] ?? 'knowledge';
+    const resolved = resolveTypeAlias(noteType);
+    return getTypeRegistry()[resolved] ?? 'knowledge';
+}
+export function getRegisteredTypes() {
+    return Object.keys(getTypeRegistry());
+}
+export function isRegisteredType(noteType) {
+    const resolved = resolveTypeAlias(noteType);
+    return resolved in getTypeRegistry();
+}
+export function registerType(name, delivery) {
+    const config = loadConfigFile();
+    if (!config.types)
+        config.types = {};
+    config.types[name] = delivery;
+    saveConfigFile(config);
+}
+export function validateTypeName(name) {
+    if (!name || name.length < 2) {
+        return `Type name must be at least 2 characters. Got ${name.length}.`;
+    }
+    if (name.length > 50) {
+        return `Type name must be 50 characters or fewer. Got ${name.length}.`;
+    }
+    if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name)) {
+        return `Invalid type name "${name}". Use lowercase alphanumeric + hyphens, starting with a letter (e.g., "wine-log").`;
+    }
+    return null;
 }
 // --- Queries ---
 export async function fetchPersonaNotes(supabase) {
@@ -31,7 +72,6 @@ export async function findNoteByFile(supabase, filename) {
         .from('notes')
         .select('id, metadata')
         .eq('metadata->>local_file', filename)
-        .limit(1)
         .single();
     if (byFile)
         return byFile;
@@ -40,7 +80,6 @@ export async function findNoteByFile(supabase, filename) {
         .from('notes')
         .select('id, metadata')
         .eq('metadata->>upsert_key', upsertKey)
-        .limit(1)
         .single();
     return byKey || null;
 }
@@ -164,12 +203,16 @@ function formatNotePreview(id, meta, content, maxLen = 300) {
 const TYPE_PREFIXES = {
     'feedback': ['feedback'],
     'user-preference': ['user'],
+    'persona-rule': ['persona-rule'],
+    'system-rule': ['system-rule'],
+    'code-craft': ['code-craft'],
     'architecture-decision': ['spec', 'architecture'],
     'project-status': ['project-status'],
     'reference': ['reference'],
     'event': ['devlog', 'event'],
     'error': ['errorlog', 'error'],
     'general': ['general'],
+    'knowledge-guide': ['knowledge-guide'],
 };
 /**
  * Validate upsert_key format: {prefix}-{topic} or {project}-{prefix}-{topic}
@@ -224,18 +267,6 @@ function isInteractive() {
     const config = loadConfigFile();
     return config.naming?.interactive !== false;
 }
-/** Valid note types for the interactive prompt. */
-export const NOTE_TYPES = [
-    'user-preference',
-    'feedback',
-    'architecture-decision',
-    'project-status',
-    'reference',
-    'event',
-    'error',
-    'knowledge-guide',
-    'general',
-];
 /** Valid statuses for notes. */
 export const NOTE_STATUSES = ['idea', 'planning', 'active', 'done'];
 /**
@@ -251,8 +282,7 @@ export function checkMetadataCompleteness(metadata, type) {
         missing.push('upsert_key');
     }
     // Only ask for status on project-scoped types
-    const projectTypes = ['architecture-decision', 'project-status', 'event', 'error'];
-    if (projectTypes.includes(type) && !metadata.status) {
+    if (inferDelivery(type) === 'project' && !metadata.status) {
         missing.push('status');
     }
     if (missing.length === 0)
@@ -367,7 +397,7 @@ export async function opListNotes(clients, limit, type, project) {
     }).join('\n\n---\n\n');
     return { status: 'ok', message: formatted };
 }
-export async function opAddNote(clients, content, type, agent, metadata, force) {
+export async function opAddNote(clients, content, type, agent, metadata, force, registerTypeFlag) {
     const upsertKey = metadata.upsert_key;
     const description = metadata.description;
     const skippedInteractive = metadata.interactive_skip === true;
@@ -381,6 +411,29 @@ export async function opAddNote(clients, content, type, agent, metadata, force)
     }
     // Clean up the skip flag before saving
     delete metadata.interactive_skip;
+    // --- Type resolution and registration ---
+    const resolvedType = resolveTypeAlias(type);
+    // If register_type flag is set and type is unknown, register it
+    if (registerTypeFlag && !isRegisteredType(resolvedType)) {
+        const nameError = validateTypeName(resolvedType);
+        if (nameError)
+            return { status: 'error', message: nameError };
+        const delivery = metadata.delivery || 'knowledge';
+        registerType(resolvedType, delivery);
+    }
+    // If type is still unknown after potential registration, prompt
+    if (!isRegisteredType(resolvedType)) {
+        const registry = getTypeRegistry();
+        const typeListStr = Object.entries(registry)
+            .map(([t, d]) => `${t} (${d})`)
+            .join(', ');
+        return {
+            status: 'confirm',
+            message: `Type "${type}" is not registered.\n\nOptions:\n1. Register with delivery "knowledge" (default) — re-call add_note with register_type: true\n2. Register with specific delivery — re-call add_note with register_type: true AND set metadata.delivery to "persona", "project", or "knowledge"\n3. Use an existing type instead — re-call add_note with one of: ${typeListStr}\n4. Cancel\n\nAsk the user which option they prefer.`,
+        };
+    }
+    // Use resolved type for the rest of the flow
+    type = resolvedType;
     // Naming enforcement (opt-in via config)
     if (isNamingEnforced()) {
         const namingError = validateNaming(upsertKey || '', type, description);
@@ -430,7 +483,6 @@ export async function opAddNote(clients, content, type, agent, metadata, force)
             .from('notes')
             .select('id, metadata, created_at')
             .eq('metadata->>upsert_key', upsertKey)
-            .limit(1)
             .single();
         if (existing) {
             return upsertExistingNote(clients, existing, content, fullMetadata);
@@ -531,6 +583,16 @@ export async function opUpdateNote(clients, id, content, metadata, confirmed = f
     if (fetchError || !existing) {
         return { status: 'error', message: `Error: note ${id} not found.` };
     }
+    // Protected delivery gate — skill-reference and other protected notes require explicit confirmation
+    const existingDelivery = existing.metadata.delivery;
+    if (existingDelivery === 'protected' && !confirmed) {
+        const existingType = existing.metadata.type;
+        const uKey = existing.metadata.upsert_key;
+        return {
+            status: 'confirm',
+            message: `⚠️ PROTECTED NOTE — "${uKey || `id ${id}`}" (type: ${existingType || 'unknown'}) has protected delivery.\n\nThis is a skill-reference note. Are you sure you want to update it? Skill reference documents are protected to prevent accidental overwrites.\n\nTo proceed, call update_note again with confirmed: true.`,
+        };
+    }
     // Confirmation gate
     if (!confirmed) {
         const currentPreview = formatNotePreview(existing.id, existing.metadata, existing.content);
@@ -602,7 +664,7 @@ export async function opUpdateNote(clients, id, content, metadata, confirmed = f
     }
     return { status: 'ok', message: `Note updated as ${chunks.length} chunks (ids: ${ids.join(', ')}, group: ${newGroupId})` };
 }
-export async function opUpdateMetadata(clients, id, metadata) {
+export async function opUpdateMetadata(clients, id, metadata, confirmed = false) {
     const { data: existing, error: fetchError } = await clients.supabase
         .from('notes')
         .select('id, metadata')
@@ -611,6 +673,16 @@ export async function opUpdateMetadata(clients, id, metadata) {
     if (fetchError || !existing) {
         return { status: 'error', message: `Error: note ${id} not found.` };
     }
+    // Protected delivery gate
+    const existingDelivery = existing.metadata.delivery;
+    if (existingDelivery === 'protected' && !confirmed) {
+        const existingType = existing.metadata.type;
+        const uKey = existing.metadata.upsert_key;
+        return {
+            status: 'confirm',
+            message: `⚠️ PROTECTED NOTE — "${uKey || `id ${id}`}" (type: ${existingType || 'unknown'}) has protected delivery.\n\nThis is a skill-reference note. Are you sure you want to update its metadata?\n\nTo proceed, call update_metadata again with confirmed: true.`,
+        };
+    }
     const merged = { ...existing.metadata, ...metadata };
     const { error } = await clients.supabase
         .from('notes')
@@ -632,6 +704,15 @@ export async function opDeleteNote(clients, id, confirmed = false) {
     }
     const meta = existing.metadata;
     const groupId = meta.chunk_group;
+    // Protected delivery gate
+    if (meta.delivery === 'protected' && !confirmed) {
+        const uKey = meta.upsert_key;
+        const existingType = meta.type;
+        return {
+            status: 'confirm',
+            message: `⚠️ PROTECTED NOTE — "${uKey || `id ${id}`}" (type: ${existingType || 'unknown'}) has protected delivery.\n\nThis is a skill-reference note. Are you sure you want to delete it? This action cannot be undone.\n\nTo proceed, call delete_note again with confirmed: true.`,
+        };
+    }
     // Confirmation gate
     if (!confirmed) {
         const chunkInfo = groupId ? ` (chunked, all chunks will be deleted)` : '';
@@ -652,3 +733,31 @@ export async function opDeleteNote(clients, id, confirmed = false) {
         return { status: 'error', message: `Error: ${error.message}` };
     return { status: 'ok', message: `Note ${id} deleted.` };
 }
+export async function checkChunkIntegrity(supabase) {
+    const { data: chunkedNotes, error } = await supabase
+        .from('notes')
+        .select('id, metadata')
+        .not('metadata->>chunk_group', 'is', null);
+    if (error || !chunkedNotes)
+        return { incompleteGroups: [] };
+    const groups = new Map();
+    for (const note of chunkedNotes) {
+        const meta = note.metadata;
+        const groupId = meta.chunk_group;
+        if (!groups.has(groupId))
+            groups.set(groupId, []);
+        groups.get(groupId).push({
+            id: note.id,
+            index: meta.chunk_index,
+            total: meta.total_chunks,
+        });
+    }
+    const incompleteGroups = [];
+    for (const [groupId, chunks] of groups) {
+        const expected = chunks[0].total;
+        if (chunks.length !== expected) {
+            incompleteGroups.push({ groupId, expected, found: chunks.length });
+        }
+    }
+    return { incompleteGroups };
+}