@aperdomoll90/ledger-ai 1.1.3 → 1.3.0

package/README.md

@@ -41,7 +41,7 @@ ledger init    # connect to existing Supabase, pull persona, set up platform
 
 **For you:** Define who you are, how you want AI to behave, your coding conventions, communication style. Do it once. Every AI agent on every device follows the same rules.
 
-**For your agents:** Semantic search over your knowledge base. Notes are embedded with OpenAI and stored in Postgres with pgvector. Agents find relevant context by meaning, not keywords.
+**For your agents:** A full RAG (Retrieval-Augmented Generation) system. Notes are embedded with OpenAI and stored in Postgres with pgvector. Agents find relevant context by semantic meaning, not keywords. Retrieved context is injected into agent prompts automatically via MCP.
 
 **For your workflow:** Automatic sync at session start, conflict detection, session-end checks. Hooks enforce rules (block credential file access, auto-ingest notes to Ledger).
 
@@ -153,10 +153,16 @@ npm run release    # version bump → build → test → publish to npm
 
 ## Roadmap
 
-- Multi-provider embeddings (Supabase built-in, OpenAI, others)
+### RAG Enhancements
+- Hybrid search (vector + BM25 keyword via PostgreSQL full-text search)
+- Re-ranking — score retrieved chunks before feeding to LLM
+- Chunking strategies for large documents (auto-split on ingest)
+- Multi-format ingest (PDF, Excel, images, audio)
+- Multi-provider embeddings (Supabase built-in, OpenAI, Ollama, Cohere)
+
+### Platform
 - Note versioning / history
 - Soft delete (trash)
-- Multi-format ingest (PDF, Excel, images, audio)
 - Web dashboard
 - Skills system (context-aware convention enforcement)
 - VS Code extension

package/dist/cli.js

@@ -6,7 +6,7 @@ const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 import { pull } from './commands/pull.js';
 import { push } from './commands/push.js';
-import { check } from './commands/check.js';
+import { check, checkChunks } from './commands/check.js';
 import { sync } from './commands/sync.js';
 import { show } from './commands/show.js';
 import { exportNote } from './commands/export.js';
@@ -17,13 +17,14 @@ import { setupClaudeCode, setupOpenclaw, setupChatgpt } from './commands/setup.j
 import { backup, enableBackupCron, disableBackupCron } from './commands/backup.js';
 import { restore } from './commands/restore.js';
 import { onboard } from './commands/onboard.js';
-import { configGet, configSet, configList } from './commands/config.js';
+import { configGet, configSet, configUnset, configList } from './commands/config.js';
 import { migrate } from './commands/migrate.js';
 import { add } from './commands/add.js';
 import { update } from './commands/update.js';
 import { deleteNote } from './commands/delete.js';
 import { list } from './commands/list.js';
 import { tag } from './commands/tag.js';
+import { lint } from './commands/lint.js';
 process.on('unhandledRejection', (err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -51,10 +52,16 @@ program
 });
 program
     .command('check')
-    .description('Compare local files vs Ledger, report sync status (alias for sync --dry-run)')
-    .action(async () => {
+    .description('Compare local files vs Ledger, report sync status')
+    .option('--chunks', 'Check chunk group integrity')
+    .action(async (opts) => {
     const config = loadConfig();
-    await check(config);
+    if (opts.chunks) {
+        await checkChunks(config);
+    }
+    else {
+        await check(config);
+    }
 });
 program
     .command('sync')
@@ -133,7 +140,25 @@ configCmd
     .command('set <key> <value>')
     .description('Set a config value')
     .action(async (key, value) => {
-    await configSet(key, value);
+    if (key.startsWith('types.')) {
+        const config = loadConfig();
+        await configSet(key, value, { supabase: config.supabase, openai: config.openai });
+    }
+    else {
+        await configSet(key, value);
+    }
+});
+configCmd
+    .command('unset <key>')
+    .description('Remove a config override (types.* keys only)')
+    .action(async (key) => {
+    if (key.startsWith('types.')) {
+        const config = loadConfig();
+        await configUnset(key, { supabase: config.supabase, openai: config.openai });
+    }
+    else {
+        await configUnset(key);
+    }
 });
 configCmd
     .command('list')
@@ -254,4 +279,12 @@ program
         scope: options.scope,
     });
 });
+program
+    .command('lint')
+    .description('Add lint configs to the current project based on detected stack')
+    .option('--personal', 'include personal conventions (BEM, SCSS patterns)')
+    .option('--diff', 'compare local configs against Ledger versions')
+    .action(async (options) => {
+    await lint({ personal: options.personal ?? false, diff: options.diff ?? false });
+});
 program.parse();

package/dist/commands/add.js

@@ -1,5 +1,5 @@
 import { loadConfigFile } from '../lib/config.js';
-import { opAddNote, NOTE_TYPES, NOTE_STATUSES } from '../lib/notes.js';
+import { opAddNote, getRegisteredTypes, isRegisteredType, registerType, validateTypeName, inferDelivery, NOTE_STATUSES } from '../lib/notes.js';
 import { ask, confirm, choose } from '../lib/prompt.js';
 export async function add(config, content, options) {
     const configFile = loadConfigFile();
@@ -18,12 +18,37 @@ export async function add(config, content, options) {
     if (interactive && !options.force) {
         // Type
         if (!type) {
+            const registeredTypes = getRegisteredTypes();
             const typeChoice = await choose('What type of note is this?', [
-                ...NOTE_TYPES,
+                ...registeredTypes,
                 'skip — use default (general)',
             ]);
             type = typeChoice.startsWith('skip') ? 'general' : typeChoice;
         }
+        // Handle unknown type from --type flag
+        if (type && !isRegisteredType(type)) {
+            console.error(`\nType "${type}" is not registered.`);
+            const action = await choose('What would you like to do?', [
+                'register — register it now (pick a delivery tier)',
+                'existing — use an existing type instead',
+                'proceed — save anyway (defaults to "knowledge" delivery)',
+            ]);
+            if (action.startsWith('register')) {
+                const nameError = validateTypeName(type);
+                if (nameError) {
+                    console.error(nameError);
+                    process.exit(1);
+                }
+                const deliveryChoice = await choose('Delivery tier?', ['persona', 'project', 'knowledge', 'protected']);
+                registerType(type, deliveryChoice);
+                console.error(`Registered type "${type}" with delivery "${deliveryChoice}".`);
+            }
+            else if (action.startsWith('existing')) {
+                const registeredTypes = getRegisteredTypes();
+                type = await choose('Choose a type:', registeredTypes);
+            }
+            // 'proceed' — use the type as-is, will default to knowledge delivery
+        }
         // Description
         if (!metadata.description) {
             const desc = await ask('One-line description (what is this note for?): ');
@@ -43,8 +68,7 @@ export async function add(config, content, options) {
                 metadata.project = proj;
         }
         // Status (only for project-scoped types)
-        const projectTypes = ['architecture-decision', 'project-status', 'event', 'error'];
-        if (projectTypes.includes(type) && !metadata.status) {
+        if (inferDelivery(type) === 'project' && !metadata.status) {
             const statusChoice = await choose('What stage is this?', [
                 ...NOTE_STATUSES,
                 'skip — no status',

package/dist/commands/check.js

@@ -1,6 +1,6 @@
 import { readFileSync, readdirSync, existsSync } from 'fs';
 import { resolve } from 'path';
-import { fetchNoteHashes } from '../lib/notes.js';
+import { fetchNoteHashes, checkChunkIntegrity } from '../lib/notes.js';
 import { contentHash } from '../lib/hash.js';
 export async function check(config) {
     const result = {
@@ -77,3 +77,15 @@ export async function check(config) {
     }
     return result;
 }
+export async function checkChunks(config) {
+    console.error('Checking chunk integrity...');
+    const result = await checkChunkIntegrity(config.supabase);
+    if (result.incompleteGroups.length === 0) {
+        console.log('All chunk groups are complete.');
+        return;
+    }
+    console.error(`Found ${result.incompleteGroups.length} incomplete chunk group(s):`);
+    for (const group of result.incompleteGroups) {
+        console.error(`  group ${group.groupId}: expected ${group.expected} chunks, found ${group.found}`);
+    }
+}

package/dist/commands/config.js

@@ -1,22 +1,8 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { getLedgerDir, saveConfigFile, loadConfigFile } from '../lib/config.js';
+import { BUILTIN_TYPES, getTypeRegistry, opUpdateMetadata, validateTypeName } from '../lib/notes.js';
+import { choose, confirm } from '../lib/prompt.js';
 import { resolve } from 'path';
-import { getLedgerDir } from '../lib/config.js';
-import { confirm } from '../lib/prompt.js';
 const CONFIG_PATH = resolve(getLedgerDir(), 'config.json');
-function loadFullConfig() {
-    if (existsSync(CONFIG_PATH)) {
-        try {
-            return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    return {};
-}
-function saveConfig(config) {
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
-}
 const SECURITY_WARNINGS = {
     envBlocking: 'This disables .env file protection.\nYour API keys and credentials will be readable by the AI agent.',
     mcpJsonBlocking: 'This allows direct editing of mcp.json.\nMCP servers should be registered via `claude mcp add`, not by editing config files.',
@@ -35,7 +21,7 @@ const DEVICE_DESCRIPTIONS = {
     'device.alias': 'Name for this device',
 };
 export async function configGet(key) {
-    const config = loadFullConfig();
+    const config = loadConfigFile();
     if (key === 'all') {
         console.log(JSON.stringify(config, null, 2));
         return;
@@ -76,13 +62,42 @@ export async function configGet(key) {
         console.log(`${key}: ${defaults[key]} (default)`);
         return;
     }
-    const allKeys = [...Object.keys(DESCRIPTIONS), ...Object.keys(NAMING_DESCRIPTIONS), ...Object.keys(DEVICE_DESCRIPTIONS), 'memoryDir', 'claudeMdPath', 'all'];
+    // Handle type registry
+    if (key === 'types') {
+        const registry = getTypeRegistry();
+        const userTypes = config.types ?? {};
+        console.error('Type registry:');
+        for (const [typeName, delivery] of Object.entries(registry)) {
+            const isBuiltin = typeName in BUILTIN_TYPES;
+            const isOverridden = isBuiltin && typeName in userTypes;
+            const isCustom = !isBuiltin;
+            let annotation = isCustom ? '(custom)' : '(built-in)';
+            if (isOverridden) {
+                annotation = `(built-in, overridden — default: ${BUILTIN_TYPES[typeName]})`;
+            }
+            console.error(`  ${typeName}: ${delivery} ${annotation}`);
+        }
+        return;
+    }
+    if (key.startsWith('types.')) {
+        const typeName = key.slice(6);
+        const registry = getTypeRegistry();
+        if (typeName in registry) {
+            const isBuiltin = typeName in BUILTIN_TYPES;
+            console.log(`${typeName}: ${registry[typeName]} (${isBuiltin ? 'built-in' : 'custom'})`);
+        }
+        else {
+            console.log(`${typeName}: not registered`);
+        }
+        return;
+    }
+    const allKeys = [...Object.keys(DESCRIPTIONS), ...Object.keys(NAMING_DESCRIPTIONS), ...Object.keys(DEVICE_DESCRIPTIONS), 'memoryDir', 'claudeMdPath', 'types', 'all'];
     console.error(`Unknown config key: ${key}`);
     console.error(`Available: ${allKeys.join(', ')}`);
     process.exit(1);
 }
-export async function configSet(key, value) {
-    const config = loadFullConfig();
+export async function configSet(key, value, clients) {
+    const config = loadConfigFile();
     // Handle hook settings
     const hookKeys = ['envBlocking', 'mcpJsonBlocking', 'writeInterception', 'sessionEndCheck'];
     if (hookKeys.includes(key)) {
@@ -104,7 +119,7 @@ export async function configSet(key, value) {
         if (!config.hooks)
             config.hooks = {};
         config.hooks[key] = boolValue;
-        saveConfig(config);
+        saveConfigFile(config);
         const state = boolValue ? 'enabled' : 'disabled';
         console.error(`${key}: ${state}`);
         console.error('Run `ledger setup claude-code` to apply hook changes.');
@@ -118,31 +133,132 @@ export async function configSet(key, value) {
             config.naming = {};
         const field = key.split('.')[1];
         config.naming[field] = boolValue;
-        saveConfig(config);
+        saveConfigFile(config);
         console.error(`${key}: ${boolValue ? 'enabled' : 'disabled'}`);
         return;
     }
     // Handle device alias
     if (key === 'device.alias') {
         config.device = { alias: value };
-        saveConfig(config);
+        saveConfigFile(config);
         console.error(`device.alias: ${value}`);
         return;
     }
     // Handle path settings
     if (key === 'memoryDir' || key === 'claudeMdPath') {
         config[key] = value;
-        saveConfig(config);
+        saveConfigFile(config);
         console.error(`${key}: ${value}`);
         return;
     }
-    const allKeys = [...hookKeys, ...namingKeys, 'device.alias', 'memoryDir', 'claudeMdPath'];
+    // Handle type registry
+    if (key.startsWith('types.')) {
+        const typeName = key.slice(6);
+        const delivery = value;
+        if (!['persona', 'project', 'knowledge', 'protected'].includes(delivery)) {
+            console.error(`Invalid delivery tier: "${value}". Must be: persona, project, knowledge, or protected.`);
+            process.exit(1);
+        }
+        const nameError = validateTypeName(typeName);
+        if (nameError) {
+            console.error(nameError);
+            process.exit(1);
+        }
+        const oldDelivery = config.types?.[typeName] ?? BUILTIN_TYPES[typeName];
+        if (!config.types)
+            config.types = {};
+        config.types[typeName] = delivery;
+        saveConfigFile(config);
+        const isBuiltin = typeName in BUILTIN_TYPES;
+        const action = isBuiltin ? 'overridden' : 'registered';
+        console.error(`types.${typeName}: ${delivery} (${action})`);
+        // Delivery change propagation — only if we have DB access and delivery actually changed
+        if (clients && oldDelivery && oldDelivery !== delivery) {
+            const { data: notes } = await clients.supabase
+                .from('notes')
+                .select('id, metadata')
+                .eq('metadata->>type', typeName);
+            const affected = (notes ?? []).filter((n) => n.metadata.delivery !== delivery);
+            if (affected.length > 0) {
+                console.error(`\n${affected.length} note(s) currently have a different delivery:`);
+                for (const note of affected) {
+                    const meta = note.metadata;
+                    const uKey = meta.upsert_key || `id-${note.id}`;
+                    console.error(`  [${note.id}] ${uKey} — delivery: ${meta.delivery}`);
+                }
+                const action = await choose('\nUpdate delivery on these notes?', [
+                    'all — update all notes',
+                    'select — choose individually',
+                    'none — only affect new notes',
+                ]);
+                if (action.startsWith('all')) {
+                    for (const note of affected) {
+                        await opUpdateMetadata(clients, note.id, { delivery });
+                    }
+                    console.error(`Updated delivery to "${delivery}" on ${affected.length} note(s).`);
+                }
+                else if (action.startsWith('select')) {
+                    let updated = 0;
+                    for (const note of affected) {
+                        const meta = note.metadata;
+                        const uKey = meta.upsert_key || `id-${note.id}`;
+                        const yes = await confirm(`  Update [${note.id}] ${uKey}?`);
+                        if (yes) {
+                            await opUpdateMetadata(clients, note.id, { delivery });
+                            updated++;
+                        }
+                    }
+                    console.error(`Updated delivery on ${updated} note(s).`);
+                }
+            }
+        }
+        return;
+    }
+    const allKeys = [...hookKeys, ...namingKeys, 'device.alias', 'memoryDir', 'claudeMdPath', 'types.*'];
     console.error(`Unknown config key: ${key}`);
     console.error(`Available: ${allKeys.join(', ')}`);
     process.exit(1);
 }
+export async function configUnset(key, clients) {
+    if (!key.startsWith('types.')) {
+        console.error(`Unset is only supported for types.* keys. Got: ${key}`);
+        process.exit(1);
+    }
+    const typeName = key.slice(6);
+    const config = loadConfigFile();
+    const userTypes = config.types ?? {};
+    if (!(typeName in userTypes)) {
+        console.error(`No user override for "${typeName}".`);
+        return;
+    }
+    const isBuiltin = typeName in BUILTIN_TYPES;
+    if (!isBuiltin && clients) {
+        const { data: notes } = await clients.supabase
+            .from('notes')
+            .select('id')
+            .eq('metadata->>type', typeName);
+        if (notes && notes.length > 0) {
+            console.error(`\n${notes.length} note(s) use type "${typeName}". They will become unregistered (delivery defaults to "knowledge").`);
+            const proceed = await confirm('Proceed?');
+            if (!proceed) {
+                console.error('Cancelled.');
+                return;
+            }
+        }
+    }
+    delete config.types[typeName];
+    if (config.types && Object.keys(config.types).length === 0)
+        delete config.types;
+    saveConfigFile(config);
+    if (isBuiltin) {
+        console.error(`Reverted "${typeName}" to built-in default: ${BUILTIN_TYPES[typeName]}`);
+    }
+    else {
+        console.error(`Removed custom type "${typeName}".`);
+    }
+}
 export async function configList() {
-    const config = loadFullConfig();
+    const config = loadConfigFile();
     const hooks = config.hooks || {};
     console.error('Hook settings:');
     for (const [key, desc] of Object.entries(DESCRIPTIONS)) {
@@ -163,5 +279,20 @@ export async function configList() {
     console.error('\nPaths:');
     console.error(`  memoryDir: ${config.memoryDir || '(default)'}`);
     console.error(`  claudeMdPath: ${config.claudeMdPath || '(default)'}`);
+    const registry = getTypeRegistry();
+    const userTypes = config.types ?? {};
+    const customTypes = Object.keys(userTypes).filter(t => !(t in BUILTIN_TYPES));
+    const overrides = Object.keys(userTypes).filter(t => t in BUILTIN_TYPES);
+    console.error('\nType registry:');
+    if (customTypes.length > 0) {
+        console.error(`  Custom types: ${customTypes.map(t => `${t} (${userTypes[t]})`).join(', ')}`);
+    }
+    if (overrides.length > 0) {
+        console.error(`  Overrides: ${overrides.map(t => `${t}: ${userTypes[t]} (default: ${BUILTIN_TYPES[t]})`).join(', ')}`);
+    }
+    if (customTypes.length === 0 && overrides.length === 0) {
+        console.error('  No custom types or overrides. Using built-in defaults.');
+    }
+    console.error(`  Built-in types: ${Object.keys(BUILTIN_TYPES).length}`);
     console.error('\nConfig file: ' + CONFIG_PATH);
 }

package/dist/commands/ingest.js

@@ -108,7 +108,7 @@ async function ingestFile(config, filePath, existingNotes) {
     const defaultDelivery = inferDelivery(noteType);
     const deliveryChoice = await choose(`Delivery tier (default: ${defaultDelivery}):`, [
         `${defaultDelivery} (default)`,
-        ...['persona', 'project', 'knowledge'].filter(d => d !== defaultDelivery),
+        ...['persona', 'project', 'knowledge', 'protected'].filter(d => d !== defaultDelivery),
     ]);
     const delivery = deliveryChoice.replace(' (default)', '');
     const { openai } = config;

package/dist/commands/lint.js

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+import { createInterface } from 'readline';
+import { detectStack, getConfigsForStack, ESLINT_TS, ESLINT_TS_REACT, STYLELINT_UNIVERSAL, } from '../lib/lint-configs.js';
+// --- Helpers ---
+async function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(`${question} [y/N] `, (answer) => {
+            rl.close();
+            resolve(answer.trim() === 'y' || answer.trim() === 'yes');
+        });
+    });
+}
+// --- writeConfig ---
+export async function writeConfig(projectDir, config) {
+    const filePath = resolve(projectDir, config.filename);
+    if (existsSync(filePath)) {
+        const existing = readFileSync(filePath, 'utf-8');
+        if (existing === config.content) {
+            console.error(`  ${config.filename} — already up to date`);
+            return;
+        }
+        const overwrite = await confirm(`  ${config.filename} already exists. Overwrite?`);
+        if (!overwrite) {
+            console.error(`  ${config.filename} — skipped`);
+            return;
+        }
+    }
+    writeFileSync(filePath, config.content, 'utf-8');
+    console.error(`  ${config.filename} — written`);
+}
+function getUniversalConfigs(hasReact) {
+    return {
+        eslint: { filename: 'eslint.config.js', content: hasReact ? ESLINT_TS_REACT : ESLINT_TS },
+        stylelint: { filename: '.stylelintrc.json', content: STYLELINT_UNIVERSAL },
+    };
+}
+export async function handleDiff(projectDir, configs, universalConfigs) {
+    const toCheck = [];
+    if (configs.eslint) {
+        toCheck.push({ filename: configs.eslint.filename, template: configs.eslint.content });
+        // Also check universal if writing personal
+        if (configs.eslint.filename !== universalConfigs.eslint.filename) {
+            toCheck.push({ filename: universalConfigs.eslint.filename, template: universalConfigs.eslint.content });
+        }
+    }
+    if (configs.stylelint) {
+        toCheck.push({ filename: configs.stylelint.filename, template: configs.stylelint.content });
+        if (configs.stylelint.filename !== universalConfigs.stylelint.filename) {
+            toCheck.push({ filename: universalConfigs.stylelint.filename, template: universalConfigs.stylelint.content });
+        }
+    }
+    if (toCheck.length === 0) {
+        console.error('No lint configs applicable for this project stack.');
+        return;
+    }
+    let anyDiff = false;
+    for (const { filename, template } of toCheck) {
+        const filePath = resolve(projectDir, filename);
+        if (!existsSync(filePath)) {
+            console.error(`  ${filename} — not found (run without --diff to create)`);
+            anyDiff = true;
+            continue;
+        }
+        const existing = readFileSync(filePath, 'utf-8');
+        if (existing === template) {
+            console.error(`  ${filename} — up to date`);
+        }
+        else {
+            console.error(`  ${filename} — differs from Ledger template`);
+            anyDiff = true;
+            const update = await confirm(`  Update ${filename} to Ledger version?`);
+            if (update) {
+                writeFileSync(filePath, template, 'utf-8');
+                console.error(`  ${filename} — updated`);
+            }
+        }
+    }
+    if (!anyDiff) {
+        console.error('\nAll configs are up to date.');
+    }
+}
+// --- checkDependencies ---
+const ESLINT_TS_DEPS = ['typescript-eslint', 'eslint-plugin-import'];
+const ESLINT_REACT_DEPS = ['eslint-plugin-react', 'eslint-plugin-jsx-a11y'];
+const STYLELINT_DEPS = ['stylelint', 'stylelint-config-standard-scss'];
+export async function checkDependencies(projectDir, stack, personal) {
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return;
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    const installed = new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+    ]);
+    const needed = [];
+    const needsEslint = stack.hasTypeScript || stack.hasReact;
+    const needsStylelint = stack.hasScss;
+    if (needsEslint) {
+        for (const dep of ESLINT_TS_DEPS) {
+            if (!installed.has(dep))
+                needed.push(dep);
+        }
+        if (stack.hasReact) {
+            for (const dep of ESLINT_REACT_DEPS) {
+                if (!installed.has(dep))
+                    needed.push(dep);
+            }
+        }
+    }
+    if (needsStylelint) {
+        for (const dep of STYLELINT_DEPS) {
+            if (!installed.has(dep))
+                needed.push(dep);
+        }
+    }
+    if (personal) {
+        // no extra deps for personal configs
+    }
+    if (needed.length === 0)
+        return;
+    console.error('\nMissing devDependencies:');
+    for (const dep of needed) {
+        console.error(`  - ${dep}`);
+    }
+    const install = await confirm('\nInstall missing dependencies now?');
+    if (install) {
+        execSync(`npm install --save-dev ${needed.join(' ')}`, { stdio: 'inherit', cwd: projectDir });
+    }
+}
+// --- Main lint command ---
+export async function lint(options) {
+    const projectDir = process.cwd();
+    console.error('Detecting project stack...');
+    const stack = detectStack(projectDir);
+    console.error(`  package.json: ${stack.hasPackageJson}`);
+    console.error(`  TypeScript:   ${stack.hasTypeScript}`);
+    console.error(`  React:        ${stack.hasReact}`);
+    console.error(`  SCSS:         ${stack.hasScss}`);
+    console.error('');
+    const configs = getConfigsForStack(stack, options.personal);
+    const universalConfigs = getUniversalConfigs(stack.hasReact);
+    if (!configs.eslint && !configs.stylelint) {
+        console.error('No lint configs applicable for this stack (needs TypeScript, React, or SCSS).');
+        return;
+    }
+    if (options.diff) {
+        console.error('Comparing local configs against Ledger templates...\n');
+        await handleDiff(projectDir, configs, universalConfigs);
+        return;
+    }
+    console.error('Writing lint configs...\n');
+    // When personal, also write the universal configs that personal ones extend
+    if (options.personal) {
+        if (configs.eslint) {
+            await writeConfig(projectDir, universalConfigs.eslint);
+        }
+        if (configs.stylelint) {
+            await writeConfig(projectDir, universalConfigs.stylelint);
+        }
+    }
+    if (configs.eslint) {
+        await writeConfig(projectDir, configs.eslint);
+    }
+    if (configs.stylelint) {
+        await writeConfig(projectDir, configs.stylelint);
+    }
+    console.error('');
+    await checkDependencies(projectDir, stack, options.personal);
+    console.error('\nDone.');
+}