design-brain-memory 0.9.2 → 0.9.4

package/dist/cli.js

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
 import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
-import { loadTasteProfile } from './store.js';
-import { askBrain, initBrain, ingestInspiration, recordOutcome, reindexBrain, searchBrain, } from './commands.js';
-import { applyDecision, nextClarifyingQuestion } from './tasteRefine.js';
-import { buildTasteProfile } from './taste.js';
-import { cherryPickComponent, scoreTaste } from './tasteDiff.js';
-import { generateFromTaste } from './tasteGenerate.js';
-import { renderTasteDiff, renderTasteProfile } from './tasteRenderer.js';
-import { confirmPrompt, shouldSkipPrompts } from './interactive.js';
+import { batchCapture } from './batch.js';
+import { askBrain, compareCaptures, detectAndWriteTrends, exportDesignSystem, generateComponentGraphCmd, generateMoodboard, generateReviewChecklist, initBrain, ingestInspiration, nameTokensCmd, recordOutcome, reindexBrain, runSystemDiff, searchBrain, analyzeWritingStyleCmd, buildGraphView, buildWiki, generateContext, } from './commands.js';
+import { runScorecard } from './scorecard.js';
+import { shouldSkipPrompts } from './interactive.js';
 import { resolveLlmConfig } from './llm.js';
-import { maybePromptSkillInstall } from './skillPrompt.js';
-import { scanDesignSystem, scanFromUrl, looksLikeUrl, normalizeToUrl } from './scan.js';
-import { renderScanResults } from './scanRenderer.js';
+import { getDefaultSkillRepo, installSkill, maybePromptSkillInstall } from './skillPrompt.js';
+import { buildTasteProfile } from './taste.js';
+import { renderTasteProfile } from './tasteRenderer.js';
 function toStringList(value) {
     if (!value) {
         return [];
@@ -46,42 +44,44 @@ function parseViewports(values) {
     });
     return parsed.length > 0 ? parsed : undefined;
 }
-function resolveTasteAnswer(answer, options) {
-    const trimmed = answer.trim();
-    if (/^\d+$/.test(trimmed)) {
-        const index = Number.parseInt(trimmed, 10) - 1;
-        if (index >= 0 && index < options.length) {
-            return options[index];
-        }
+function getVersion() {
+    try {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+        return pkg.version ?? '0.0.0';
     }
-    return trimmed;
+    catch {
+        return '0.0.0';
+    }
+}
+function printBanner(version) {
+    const DIM = '\x1b[2m';
+    const BOLD = '\x1b[1m';
+    const CYAN = '\x1b[36m';
+    const RESET = '\x1b[0m';
+    const banner = [
+        '',
+        `${BOLD}${CYAN}  ┌─────────────────────────────────────────┐${RESET}`,
+        `${BOLD}${CYAN}  │${RESET}                                         ${BOLD}${CYAN}│${RESET}`,
+        `${BOLD}${CYAN}  │${RESET}   ${BOLD}design-brain${RESET}  ${DIM}v${version}${RESET}                   ${BOLD}${CYAN}│${RESET}`,
+        `${BOLD}${CYAN}  │${RESET}   ${DIM}Relational design memory${RESET}                ${BOLD}${CYAN}│${RESET}`,
+        `${BOLD}${CYAN}  │${RESET}                                         ${BOLD}${CYAN}│${RESET}`,
+        `${BOLD}${CYAN}  └─────────────────────────────────────────┘${RESET}`,
+        '',
+    ];
+    console.log(banner.join('\n'));
 }
 async function main() {
+    const version = getVersion();
     const program = new Command();
     program
         .name('design-brain-memory')
         .description('Relational markdown design memory powered by Agent Browser CLI')
-        .version('0.9.2')
-        .option('-y, --yes', 'Skip interactive prompts');
-    /* ─── scan (default command) ─── */
-    program
-        .command('scan [path]')
-        .description('Scan codebase for design tokens and compute health score')
-        .action(async (scanPath) => {
-        const input = scanPath ?? process.cwd();
-        let result;
-        if (looksLikeUrl(input)) {
-            const url = normalizeToUrl(input);
-            result = await scanFromUrl(url);
-        }
-        else {
-            result = await scanDesignSystem(path.resolve(input));
-        }
-        renderScanResults(result);
-        const globalOptions = program.opts();
-        await maybePromptSkillInstall(shouldSkipPrompts(Boolean(globalOptions.yes)));
+        .version(version)
+        .option('-y, --yes', 'Skip interactive prompts')
+        .hook('preAction', () => {
+        printBanner(version);
     });
-    /* ─── init ─── */
     program
         .command('init')
         .description('Initialize .design-brain in the given workspace')
@@ -90,7 +90,6 @@ async function main() {
         await initBrain(path.resolve(options.root));
         console.log(`Initialized design brain at ${path.resolve(options.root, '.design-brain')}`);
     });
-    /* ─── ingest ─── */
     program
         .command('ingest')
         .description('Ingest a URL or screenshot into a project design wiki')
@@ -110,6 +109,8 @@ async function main() {
         .option('--llm-model <model>', 'LLM model id')
         .option('--llm-timeout-ms <ms>', 'LLM timeout in milliseconds', '30000')
         .option('--root <dir>', 'Workspace root', process.cwd())
+        .option('--no-visuals', 'Skip SVG visual generation')
+        .option('--live', 'Show live extraction visualization in terminal')
         .action(async (options) => {
         const llm = resolveLlmConfig({
             baseUrl: options.llmBaseUrl,
@@ -131,12 +132,13 @@ async function main() {
             llm,
             journeySteps: parseInteger(options.journeySteps, 3),
             responsiveViewports: parseViewports(options.viewport),
+            skipVisuals: !options.visuals,
+            live: options.live ?? false,
         });
         console.log(`Captured inspiration ${result.inspirationId} in project ${result.projectId}`);
         const globalOptions = program.opts();
         await maybePromptSkillInstall(shouldSkipPrompts(Boolean(globalOptions.yes)));
     });
-    /* ─── outcome ─── */
     program
         .command('outcome')
         .description('Record what the team built and link it to inspirations')
@@ -159,7 +161,6 @@ async function main() {
         });
         console.log(`Recorded outcome ${result.outcomeId} in project ${result.projectId}`);
     });
-    /* ─── search ─── */
     program
         .command('search')
         .description('Keyword search over relational design memory')
@@ -188,7 +189,6 @@ async function main() {
             console.log(`  ${result.snippet}`);
         }
     });
-    /* ─── ask ─── */
     program
         .command('ask')
         .description('Ask a design question against the design brain')
@@ -222,212 +222,246 @@ async function main() {
             }
         }
     });
-    /* ─── taste ─── */
-    const taste = program
-        .command('taste')
-        .description('Build, inspect, and apply taste profiles');
-    taste
-        .command('build <urls...>')
-        .description('Build taste profile from one or more inspiration URLs')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--name <name>', 'Readable project name')
-        .option('--headed', 'Use visible browser scan for taste analysis', false)
-        .option('--llm-base-url <url>', 'OpenAI-compatible LLM base URL')
-        .option('--llm-api-key <key>', 'LLM API key')
-        .option('--llm-model <model>', 'LLM model id')
-        .option('--llm-timeout-ms <ms>', 'LLM timeout in milliseconds', '30000')
+    program
+        .command('install-skill')
+        .description('Install Design Brain skill into your local skills registry')
+        .option('--repo <repo>', 'Skill repository override', getDefaultSkillRepo())
+        .action(async (options) => {
+        const installed = installSkill(options.repo);
+        if (!installed) {
+            throw new Error(`Skill install failed. Try manually: npx -y skills add ${options.repo}`);
+        }
+        console.log(`Installed skill from ${options.repo}`);
+    });
+    program
+        .command('reindex')
+        .description('Regenerate markdown wiki and relation graph from database.json')
         .option('--root <dir>', 'Workspace root', process.cwd())
-        .action(async (urls, options) => {
-        const llm = resolveLlmConfig({
-            baseUrl: options.llmBaseUrl,
-            apiKey: options.llmApiKey,
-            model: options.llmModel,
-            timeoutMs: parseInteger(options.llmTimeoutMs, 30000),
+        .option('--no-visuals', 'Skip SVG visual generation')
+        .action(async (options) => {
+        await reindexBrain(path.resolve(options.root), !options.visuals);
+        console.log(`Reindexed ${path.resolve(options.root, '.design-brain')}`);
+    });
+    program
+        .command('export')
+        .description('Export design system from captured data')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .option('--format <format>', 'Export format (tailwind, style-dictionary, css-in-js)', 'tailwind')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await exportDesignSystem({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+            format: options.format,
         });
-        const profile = await buildTasteProfile({
+        console.log(`Exported ${options.format} config to ${outPath}`);
+    });
+    program
+        .command('compare')
+        .description('Compare two captures or two versions of the same URL')
+        .option('--a <id>', 'First inspiration ID')
+        .option('--b <id>', 'Second inspiration ID')
+        .option('--inspo <id>', 'Inspiration ID (compares against previous version)')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await compareCaptures({
             rootDir: path.resolve(options.root),
-            projectId: options.project,
-            projectName: options.name,
-            urls,
-            headed: options.headed,
-            llm,
+            inspoA: options.a,
+            inspoB: options.b,
+            inspo: options.inspo,
         });
-        renderTasteProfile(profile);
+        console.log(`Comparison written to ${outPath}`);
     });
-    taste
-        .command('show')
-        .description('Display saved taste profile for a project')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--json', 'Output as JSON', false)
+    program
+        .command('batch')
+        .description('Batch capture from a file of URLs')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .requiredOption('--file <path>', 'Path to URL list file (tab-separated: URL, name, tags)')
         .option('--root <dir>', 'Workspace root', process.cwd())
+        .option('--no-visuals', 'Skip SVG visual generation')
         .action(async (options) => {
-        const profile = await loadTasteProfile(path.resolve(options.root), options.project);
-        if (!profile) {
-            throw new Error(`Taste profile not found for project: ${options.project}`);
-        }
-        if (options.json) {
-            console.log(JSON.stringify(profile, null, 2));
-            return;
+        const result = await batchCapture({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+            filePath: path.resolve(options.file),
+            skipVisuals: !options.visuals,
+        });
+        console.log(`Batch complete: ${result.succeeded}/${result.total} captured`);
+        if (result.failed.length > 0) {
+            console.log(`Failed: ${result.failed.join(', ')}`);
         }
-        renderTasteProfile(profile);
     });
-    taste
-        .command('pick')
-        .description('Cherry-pick a component from an inspiration source')
-        .requiredOption('--component <kind>', 'Component kind to pick')
-        .requiredOption('--from <source>', 'Source inspiration ID, URL, or hostname')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--index <n>', 'Pick Nth matched component', '0')
-        .option('--note <text>', 'Optional note for why this was picked')
+    program
+        .command('moodboard')
+        .description('Generate visual moodboard from project captures')
+        .requiredOption('--project <project>', 'Project ID/slug')
         .option('--root <dir>', 'Workspace root', process.cwd())
         .action(async (options) => {
-        const pick = await cherryPickComponent({
+        const outPath = await generateMoodboard({
             rootDir: path.resolve(options.root),
-            projectId: options.project,
-            componentKind: options.component,
-            sourceUrlOrId: options.from,
-            index: parseInteger(options.index, 0),
-            note: options.note,
+            project: options.project,
         });
-        console.log(`Cherry-picked ${pick.componentKind} from ${pick.sourceUrl}`);
+        console.log(`Moodboard generated at ${outPath}`);
     });
-    taste
-        .command('score [scanPath]')
-        .description('Score codebase alignment against a taste profile')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--json', 'Output as JSON', false)
+    program
+        .command('trends')
+        .description('Detect design trends across captures')
+        .option('--project <project>', 'Filter to project')
         .option('--root <dir>', 'Workspace root', process.cwd())
-        .action(async (scanPath, options) => {
-        const result = await scoreTaste({
+        .action(async (options) => {
+        const result = await detectAndWriteTrends({
             rootDir: path.resolve(options.root),
-            projectId: options.project,
-            scanPath: scanPath ?? process.cwd(),
+            project: options.project,
         });
-        if (options.json) {
-            console.log(JSON.stringify(result, null, 2));
-            return;
-        }
-        renderTasteDiff(result.diff);
+        console.log(`Detected ${result.trends} trends, wrote ${result.written} notes`);
     });
-    taste
-        .command('ask')
-        .description('Resolve unresolved taste conflicts')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--answer <text>', 'Answer text or option number')
+    program
+        .command('scorecard')
+        .description('Audit local codebase against captured design tokens')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .requiredOption('--scan <path>', 'Directory to scan')
         .option('--root <dir>', 'Workspace root', process.cwd())
         .action(async (options) => {
-        const rootDir = path.resolve(options.root);
-        const profile = await loadTasteProfile(rootDir, options.project);
-        if (!profile) {
-            throw new Error(`Taste profile not found for project: ${options.project}`);
-        }
-        const next = nextClarifyingQuestion(profile);
-        if (!next) {
-            console.log('No unresolved taste conflicts.');
-            return;
-        }
-        const unresolvedIndex = profile.conflicts.findIndex((conflict) => !conflict.resolved);
-        if (unresolvedIndex < 0) {
-            console.log('No unresolved taste conflicts.');
-            return;
-        }
-        let answer = options.answer ? resolveTasteAnswer(options.answer, next.options) : '';
-        if (!answer) {
-            console.log(next.question);
-            for (let i = 0; i < next.options.length; i += 1) {
-                const shouldUse = await confirmPrompt(`Use option ${i + 1}: ${next.options[i]}?`, false);
-                if (shouldUse) {
-                    answer = next.options[i];
-                    break;
-                }
-            }
-        }
-        if (!answer) {
-            console.log('No decision applied.');
-            return;
-        }
-        const decision = await applyDecision({
-            rootDir,
-            projectId: options.project,
-            conflictIndex: unresolvedIndex,
-            answer,
+        const outPath = await runScorecard({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+            scanPath: path.resolve(options.scan),
         });
-        console.log(`Saved decision ${decision.id}: ${decision.answer}`);
+        console.log(`Scorecard written to ${outPath}`);
     });
-    taste
-        .command('generate')
-        .description('Generate code from a taste profile')
-        .option('--project <project>', 'Project ID/slug', 'default')
-        .option('--target <target>', 'Generation target: component, page, or tokens', 'component')
-        .option('--component <kind>', 'Component kind when target=component')
-        .option('--framework <name>', 'Framework hint (react, next, vue, etc.)')
-        .option('--llm-base-url <url>', 'OpenAI-compatible LLM base URL')
-        .option('--llm-api-key <key>', 'LLM API key')
-        .option('--llm-model <model>', 'LLM model id')
-        .option('--llm-timeout-ms <ms>', 'LLM timeout in milliseconds', '30000')
+    program
+        .command('component-graph')
+        .description('Generate component relationship graph for a project')
+        .requiredOption('--project <project>', 'Project ID/slug')
         .option('--root <dir>', 'Workspace root', process.cwd())
         .action(async (options) => {
-        const profile = await loadTasteProfile(path.resolve(options.root), options.project);
-        if (!profile) {
-            throw new Error(`Taste profile not found for project: ${options.project}`);
-        }
-        const target = options.target;
-        if (!['component', 'page', 'tokens'].includes(target)) {
-            throw new Error(`Invalid target: ${options.target}`);
-        }
-        const llm = target === 'tokens'
-            ? undefined
-            : resolveLlmConfig({
-                baseUrl: options.llmBaseUrl,
-                apiKey: options.llmApiKey,
-                model: options.llmModel,
-                timeoutMs: parseInteger(options.llmTimeoutMs, 30000),
-            });
-        const generated = await generateFromTaste({
-            taste: profile,
-            target,
-            componentKind: options.component,
-            framework: options.framework,
-            llm,
+        const outPath = await generateComponentGraphCmd({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+        });
+        console.log(`Component graph written to ${outPath}`);
+    });
+    program
+        .command('review')
+        .description('Generate design review checklist')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .option('--scan <path>', 'Directory to scan for codebase audit')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await generateReviewChecklist({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+            scanPath: options.scan ? path.resolve(options.scan) : undefined,
         });
-        console.log(generated.code);
-        if (generated.explanation) {
-            console.log(`\n${generated.explanation}`);
+        console.log(`Review checklist written to ${outPath}`);
+    });
+    program
+        .command('name-tokens')
+        .description('Preview human-readable token names for a project')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const map = await nameTokensCmd({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+        });
+        for (const [raw, name] of map) {
+            console.log(`${raw} → ${name}`);
         }
+        console.log(`\n${map.size} tokens named`);
     });
-    /* ─── install-skill ─── */
     program
-        .command('install-skill')
-        .description('Install Design Brain skill into your AI agents')
-        .action(async () => {
-        await maybePromptSkillInstall(false);
+        .command('wiki')
+        .description('Generate design wiki with per-project pages and shared context space')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const result = await buildWiki({
+            rootDir: path.resolve(options.root),
+        });
+        console.log(`Wiki generated: ${result.projectPages} project pages, ${result.sharedTokens} shared tokens`);
+        console.log(`Browse at ${result.wikiDir}`);
     });
-    /* ─── reindex ─── */
     program
-        .command('reindex')
-        .description('Regenerate markdown wiki and relation graph from database.json')
+        .command('graph')
+        .description('Generate interactive knowledge graph visualization')
         .option('--root <dir>', 'Workspace root', process.cwd())
         .action(async (options) => {
-        await reindexBrain(path.resolve(options.root));
-        console.log(`Reindexed ${path.resolve(options.root, '.design-brain')}`);
+        const outPath = await buildGraphView({
+            rootDir: path.resolve(options.root),
+        });
+        console.log(`Knowledge graph generated at ${outPath}`);
+        console.log('Open in your browser to explore.');
+    });
+    program
+        .command('context')
+        .description('Generate design context file for AI tools (Claude Code, Cursor)')
+        .option('--project <project>', 'Project ID (omit for unified cross-project context)')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await generateContext({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+        });
+        console.log(`Design context written to ${outPath}`);
+        console.log('Drop this file into .claude/ or .cursorrules for AI-assisted development.');
+    });
+    program
+        .command('writing-style')
+        .description('Analyze writing style patterns across captured content')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await analyzeWritingStyleCmd({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+        });
+        console.log(`Writing style analysis written to ${outPath}`);
+    });
+    program
+        .command('system-diff')
+        .description('Diff design systems between projects or over time')
+        .option('--project <project>', 'Project ID for temporal diff')
+        .option('--project-a <project>', 'First project for cross-project diff')
+        .option('--project-b <project>', 'Second project for cross-project diff')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (options) => {
+        const outPath = await runSystemDiff({
+            rootDir: path.resolve(options.root),
+            project: options.project,
+            projectA: options.projectA,
+            projectB: options.projectB,
+        });
+        console.log(`System diff written to ${outPath}`);
+    });
+    program
+        .command('taste')
+        .description('Build a taste profile from multiple design inspirations')
+        .argument('<urls...>', 'URLs or domains to analyze')
+        .requiredOption('--project <project>', 'Project ID/slug')
+        .option('--project-name <name>', 'Readable project name')
+        .option('--headed', 'Use visible browser for capture', false)
+        .option('--llm-base-url <url>', 'OpenAI-compatible LLM base URL')
+        .option('--llm-api-key <key>', 'LLM API key')
+        .option('--llm-model <model>', 'LLM model id')
+        .option('--llm-timeout-ms <ms>', 'LLM timeout in milliseconds', '30000')
+        .option('--root <dir>', 'Workspace root', process.cwd())
+        .action(async (urls, options) => {
+        const llm = resolveLlmConfig({
+            baseUrl: options.llmBaseUrl,
+            apiKey: options.llmApiKey,
+            model: options.llmModel,
+            timeoutMs: parseInteger(options.llmTimeoutMs, 30000),
+        });
+        const profile = await buildTasteProfile({
+            rootDir: path.resolve(options.root),
+            projectId: options.project,
+            projectName: options.projectName,
+            urls,
+            headed: options.headed,
+            llm,
+        });
+        console.log(renderTasteProfile(profile));
     });
-    /* ─── Default command routing ─── */
-    // Bare URLs/domains route to `taste build`.
-    // Bare local paths route to `scan`.
-    // No args defaults to `scan`.
-    const commandNames = program.commands.map((command) => command.name());
-    const firstArg = process.argv[2];
-    if (!firstArg) {
-        process.argv.splice(2, 0, 'scan');
-    }
-    else if (!firstArg.startsWith('-') && !commandNames.includes(firstArg)) {
-        if (looksLikeUrl(firstArg)) {
-            process.argv.splice(2, 0, 'taste', 'build');
-        }
-        else {
-            process.argv.splice(2, 0, 'scan');
-        }
-    }
     await program.parseAsync(process.argv);
 }
 main().catch((error) => {