@timmeck/brain 1.0.0 → 1.1.1

package/src/cli/commands/config.ts

@@ -0,0 +1,169 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+import { c, icons, header, divider } from '../colors.js';
+
+function getConfigPath(): string {
+  return path.join(getDataDir(), 'config.json');
+}
+
+function readConfig(): Record<string, unknown> {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  }
+  return {};
+}
+
+function writeConfig(config: Record<string, unknown>): void {
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+function getNestedValue(obj: Record<string, unknown>, keyPath: string): unknown {
+  const parts = keyPath.split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+function setNestedValue(obj: Record<string, unknown>, keyPath: string, value: unknown): void {
+  const parts = keyPath.split('.');
+  let current: Record<string, unknown> = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== 'object') {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+function deleteNestedValue(obj: Record<string, unknown>, keyPath: string): boolean {
+  const parts = keyPath.split('.');
+  let current: Record<string, unknown> = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== 'object') return false;
+    current = current[part] as Record<string, unknown>;
+  }
+  const last = parts[parts.length - 1];
+  if (last in current) {
+    delete current[last];
+    return true;
+  }
+  return false;
+}
+
+function parseValue(value: string): unknown {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  const num = Number(value);
+  if (!isNaN(num) && value.trim() !== '') return num;
+  // Try JSON for arrays/objects
+  if ((value.startsWith('[') && value.endsWith(']')) || (value.startsWith('{') && value.endsWith('}'))) {
+    try { return JSON.parse(value); } catch { /* fall through */ }
+  }
+  return value;
+}
+
+function printObject(obj: unknown, indent = 0): void {
+  const pad = ' '.repeat(indent);
+  if (obj === null || obj === undefined) {
+    console.log(`${pad}${c.dim('(not set)')}`);
+    return;
+  }
+  if (typeof obj !== 'object') {
+    console.log(`${pad}${c.value(String(obj))}`);
+    return;
+  }
+  for (const [key, val] of Object.entries(obj as Record<string, unknown>)) {
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      console.log(`${pad}${c.cyan(key + ':')}`);
+      printObject(val, indent + 2);
+    } else {
+      const display = Array.isArray(val) ? JSON.stringify(val) : String(val);
+      console.log(`${pad}${c.label(key + ':')} ${c.value(display)}`);
+    }
+  }
+}
+
+export function configCommand(): Command {
+  const cmd = new Command('config')
+    .description('View and modify Brain configuration');
+
+  cmd
+    .command('show')
+    .description('Show current configuration')
+    .argument('[key]', 'Specific config key (e.g., learning.intervalMs)')
+    .action((key?: string) => {
+      const config = readConfig();
+
+      if (key) {
+        const value = getNestedValue(config, key);
+        if (value === undefined) {
+          console.log(`${c.dim(`Key "${key}" is not set in config overrides.`)}`);
+        } else {
+          console.log(`${c.label(key + ':')} ${c.value(typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value))}`);
+        }
+        return;
+      }
+
+      console.log(header('Brain Configuration', icons.gear));
+      console.log(`  ${c.label('Config file:')} ${c.dim(getConfigPath())}\n`);
+
+      if (Object.keys(config).length === 0) {
+        console.log(`  ${c.dim('No custom overrides. Using defaults.')}`);
+        console.log(`  ${c.dim('Set values with:')} ${c.cyan('brain config set <key> <value>')}`);
+      } else {
+        printObject(config, 2);
+      }
+      console.log(`\n${divider()}`);
+    });
+
+  cmd
+    .command('set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Config key path (e.g., learning.intervalMs)')
+    .argument('<value>', 'Value to set')
+    .action((key: string, value: string) => {
+      const config = readConfig();
+      const parsed = parseValue(value);
+      setNestedValue(config, key, parsed);
+      writeConfig(config);
+
+      console.log(`${icons.ok}  ${c.label(key)} ${c.dim(icons.arrow)} ${c.value(String(parsed))}`);
+      console.log(`  ${c.dim('Restart the daemon for changes to take effect:')} ${c.cyan('brain stop && brain start')}`);
+    });
+
+  cmd
+    .command('delete')
+    .description('Remove a configuration override (revert to default)')
+    .argument('<key>', 'Config key path to remove')
+    .action((key: string) => {
+      const config = readConfig();
+      if (deleteNestedValue(config, key)) {
+        writeConfig(config);
+        console.log(`${icons.ok}  ${c.dim(`Removed "${key}" — will use default value.`)}`);
+        console.log(`  ${c.dim('Restart the daemon for changes to take effect:')} ${c.cyan('brain stop && brain start')}`);
+      } else {
+        console.log(`${c.dim(`Key "${key}" not found in config overrides.`)}`);
+      }
+    });
+
+  cmd
+    .command('path')
+    .description('Show the config file path')
+    .action(() => {
+      console.log(getConfigPath());
+    });
+
+  return cmd;
+}

package/src/cli/commands/dashboard.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { withIpc } from '../ipc-helper.js';
 import { writeFileSync } from 'fs';
 import { resolve } from 'path';
+import { c, icons } from '../colors.js';
 
 export function dashboardCommand(): Command {
   return new Command('dashboard')
@@ -10,13 +11,15 @@ export function dashboardCommand(): Command {
     .option('--no-open', 'Generate without opening in browser')
     .action(async (opts) => {
       await withIpc(async (client) => {
-        console.log('Fetching data from Brain...');
+        console.log(`${icons.chart}  ${c.info('Fetching data from Brain...')}`);
 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const summary: any = await client.request('analytics.summary', {});
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const network: any = await client.request('synapse.stats', {});
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const networkOverview: any = await client.request('analytics.network', { limit: 50 });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const insights: any = await client.request('research.insights', {
           activeOnly: true,
           limit: 500,
@@ -44,6 +47,9 @@ export function dashboardCommand(): Command {
         const warnings = insightList.filter((i: InsightItem) => i.type === 'warning');
         const synergies = insightList.filter((i: InsightItem) => i.type === 'synergy' || i.type === 'optimization');
 
+        // Build synapse graph data
+        const synapseEdges = Array.isArray(networkOverview?.strongestSynapses) ? networkOverview.strongestSynapses : [];
+
         const data = {
           stats: {
             modules: summary.modules?.total ?? 0,
@@ -55,6 +61,7 @@ export function dashboardCommand(): Command {
           },
           langStats,
           insights: { templates, suggestions, trends, gaps, warnings, synergies },
+          synapseEdges,
         };
 
         const html = generateHtml(data);
@@ -63,10 +70,8 @@ export function dashboardCommand(): Command {
           : resolve(import.meta.dirname, '../../../dashboard.html');
 
         writeFileSync(outPath, html, 'utf-8');
-        console.log(`Dashboard written to ${outPath}`);
-        console.log(`  Modules: ${data.stats.modules}`);
-        console.log(`  Synapses: ${data.stats.synapses}`);
-        console.log(`  Insights: ${data.stats.insights}`);
+        console.log(`${icons.ok}  ${c.success('Dashboard written to')} ${c.dim(outPath)}`);
+        console.log(`  ${c.label('Modules:')} ${c.value(data.stats.modules)}  ${c.label('Synapses:')} ${c.value(data.stats.synapses)}  ${c.label('Insights:')} ${c.value(data.stats.insights)}`);
 
         if (opts.open !== false) {
           const { exec } = await import('child_process');
@@ -83,6 +88,13 @@ interface InsightItem {
   priority?: string;
 }
 
+interface SynapseEdge {
+  source: string;
+  target: string;
+  type: string;
+  weight: number;
+}
+
 interface DashboardData {
   stats: {
     modules: number;
@@ -101,6 +113,7 @@ interface DashboardData {
     warnings: InsightItem[];
     synergies: InsightItem[];
   };
+  synapseEdges: SynapseEdge[];
 }
 
 function esc(s: string): string {
@@ -108,7 +121,7 @@ function esc(s: string): string {
 }
 
 function generateHtml(data: DashboardData): string {
-  const { stats, langStats, insights } = data;
+  const { stats, langStats, insights, synapseEdges } = data;
 
   // Build language chart bars
   const sortedLangs = Object.entries(langStats).sort((a, b) => b[1] - a[1]);
@@ -276,6 +289,14 @@ function generateHtml(data: DashboardData): string {
   .prio-low{background:rgba(139,143,176,.1);color:var(--text2);border:1px solid rgba(139,143,176,.2)}
   .empty{color:var(--text3);font-style:italic;padding:24px}
 
+  /* Graph */
+  .graph-container{position:relative;background:var(--glass);border:1px solid var(--glass-border);border-radius:var(--radius);overflow:hidden;backdrop-filter:blur(20px)}
+  #synapse-graph{width:100%;height:500px;display:block;cursor:grab}
+  #synapse-graph:active{cursor:grabbing}
+  .graph-legend{display:flex;gap:16px;flex-wrap:wrap;padding:12px 20px;border-top:1px solid var(--glass-border);font-size:.8rem;color:var(--text2)}
+  .legend-dot{display:inline-block;width:10px;height:10px;border-radius:50%;margin-right:6px;vertical-align:middle}
+  .graph-tooltip{position:absolute;display:none;background:var(--bg2);border:1px solid var(--glass-border);border-radius:8px;padding:8px 14px;font-size:.8rem;color:var(--text);pointer-events:none;z-index:10;backdrop-filter:blur(20px);box-shadow:0 8px 30px rgba(0,0,0,.3)}
+
   /* Footer */
   footer{text-align:center;padding:40px 0;border-top:1px solid var(--glass-border)}
   footer p{color:var(--text3);font-size:.8rem}
@@ -310,7 +331,8 @@ function generateHtml(data: DashboardData): string {
   <nav class="reveal reveal-delay-1">
     <a href="#stats">Stats</a>
     <a href="#languages">Languages</a>
-    <a href="#research" class="research">&#128300; Research</a>
+    <a href="#network">&#128300; Network</a>
+    <a href="#research" class="research">&#128161; Research</a>
   </nav>
 
   <section id="stats" class="reveal reveal-delay-2">
@@ -330,7 +352,22 @@ function generateHtml(data: DashboardData): string {
     <div class="lang-chart">${langBars}</div>
   </section>
 
-  <section id="research" class="reveal reveal-delay-4">
+  <section id="network" class="reveal reveal-delay-4">
+    <div class="section-title"><div class="icon" style="background:rgba(71,229,255,.1)">&#128300;</div> Synapse Network</div>
+    <div class="graph-container">
+      <canvas id="synapse-graph"></canvas>
+      <div class="graph-legend">
+        <span><span class="legend-dot" style="background:var(--blue)"></span> error</span>
+        <span><span class="legend-dot" style="background:var(--green)"></span> solution</span>
+        <span><span class="legend-dot" style="background:var(--purple)"></span> code_module</span>
+        <span><span class="legend-dot" style="background:var(--orange)"></span> project</span>
+        <span><span class="legend-dot" style="background:var(--cyan)"></span> other</span>
+      </div>
+      <div id="graph-tooltip" class="graph-tooltip"></div>
+    </div>
+  </section>
+
+  <section id="research" class="reveal reveal-delay-5">
     <div class="section-title"><div class="icon" style="background:rgba(71,229,255,.1)">&#128300;</div> Research Insights</div>
     <div class="tab-bar">
       <button class="tab-btn active" data-tab="templates">&#127912; Templates <span class="count">${insights.templates.length}</span></button>
@@ -489,6 +526,192 @@ setTimeout(() => {
     el.style.width = el.dataset.target + '%';
   });
 }, 500);
+
+// --- Synapse Force-Directed Graph ---
+(function(){
+  const edges = ${JSON.stringify(synapseEdges.map((e: SynapseEdge) => ({ s: e.source, t: e.target, type: e.type, w: e.weight })))};
+  const canvas = document.getElementById('synapse-graph');
+  if (!canvas || !edges.length) return;
+  const ctx = canvas.getContext('2d');
+  const container = canvas.parentElement;
+  let W, H, dpr;
+
+  const NODE_COLORS = {
+    error: '#ff5577', solution: '#3dffa0', code_module: '#b47aff',
+    project: '#ffb347', rule: '#5b9cff', antipattern: '#ff5577'
+  };
+  const DEFAULT_COLOR = '#47e5ff';
+
+  // Build graph nodes & edges
+  const nodeMap = new Map();
+  const graphEdges = [];
+  for (const e of edges) {
+    if (!nodeMap.has(e.s)) nodeMap.set(e.s, { id: e.s, type: e.s.split(':')[0], x: 0, y: 0, vx: 0, vy: 0, connections: 0 });
+    if (!nodeMap.has(e.t)) nodeMap.set(e.t, { id: e.t, type: e.t.split(':')[0], x: 0, y: 0, vx: 0, vy: 0, connections: 0 });
+    nodeMap.get(e.s).connections++;
+    nodeMap.get(e.t).connections++;
+    graphEdges.push({ source: nodeMap.get(e.s), target: nodeMap.get(e.t), type: e.type, weight: e.w });
+  }
+  const nodes = [...nodeMap.values()];
+
+  function resize() {
+    dpr = window.devicePixelRatio || 1;
+    W = container.clientWidth;
+    H = 500;
+    canvas.width = W * dpr;
+    canvas.height = H * dpr;
+    canvas.style.width = W + 'px';
+    canvas.style.height = H + 'px';
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  }
+  resize();
+  window.addEventListener('resize', resize);
+
+  // Random initial positions
+  for (const n of nodes) {
+    n.x = W * 0.2 + Math.random() * W * 0.6;
+    n.y = H * 0.2 + Math.random() * H * 0.6;
+  }
+
+  // Force simulation
+  const REPULSION = 3000;
+  const ATTRACTION = 0.008;
+  const DAMPING = 0.85;
+  const CENTER_GRAVITY = 0.002;
+  let hovered = null;
+  let dragging = null;
+  let dragOff = {x:0,y:0};
+
+  function simulate() {
+    // Repulsion
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        let dx = nodes[i].x - nodes[j].x;
+        let dy = nodes[i].y - nodes[j].y;
+        let dist = Math.sqrt(dx*dx + dy*dy) || 1;
+        let force = REPULSION / (dist * dist);
+        let fx = (dx / dist) * force;
+        let fy = (dy / dist) * force;
+        nodes[i].vx += fx; nodes[i].vy += fy;
+        nodes[j].vx -= fx; nodes[j].vy -= fy;
+      }
+    }
+    // Attraction along edges
+    for (const e of graphEdges) {
+      let dx = e.target.x - e.source.x;
+      let dy = e.target.y - e.source.y;
+      let dist = Math.sqrt(dx*dx + dy*dy) || 1;
+      let force = (dist - 100) * ATTRACTION * e.weight;
+      let fx = (dx / dist) * force;
+      let fy = (dy / dist) * force;
+      e.source.vx += fx; e.source.vy += fy;
+      e.target.vx -= fx; e.target.vy -= fy;
+    }
+    // Center gravity
+    for (const n of nodes) {
+      n.vx += (W/2 - n.x) * CENTER_GRAVITY;
+      n.vy += (H/2 - n.y) * CENTER_GRAVITY;
+    }
+    // Apply & damp
+    for (const n of nodes) {
+      if (n === dragging) continue;
+      n.vx *= DAMPING; n.vy *= DAMPING;
+      n.x += n.vx; n.y += n.vy;
+      n.x = Math.max(20, Math.min(W - 20, n.x));
+      n.y = Math.max(20, Math.min(H - 20, n.y));
+    }
+  }
+
+  function getNodeRadius(n) { return Math.min(16, 5 + n.connections * 1.5); }
+
+  function draw() {
+    ctx.clearRect(0, 0, W, H);
+    // Edges
+    for (const e of graphEdges) {
+      const alpha = 0.15 + e.weight * 0.5;
+      ctx.strokeStyle = 'rgba(91,156,255,' + Math.min(0.8, alpha) + ')';
+      ctx.lineWidth = 0.5 + e.weight * 2;
+      ctx.beginPath();
+      ctx.moveTo(e.source.x, e.source.y);
+      ctx.lineTo(e.target.x, e.target.y);
+      ctx.stroke();
+    }
+    // Nodes
+    for (const n of nodes) {
+      const r = getNodeRadius(n);
+      const color = NODE_COLORS[n.type] || DEFAULT_COLOR;
+      const isHover = n === hovered || n === dragging;
+      // Glow
+      if (isHover) {
+        ctx.shadowColor = color;
+        ctx.shadowBlur = 20;
+      }
+      ctx.fillStyle = color;
+      ctx.globalAlpha = isHover ? 1 : 0.8;
+      ctx.beginPath();
+      ctx.arc(n.x, n.y, r, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.globalAlpha = 1;
+      ctx.shadowBlur = 0;
+      // Label for hovered or large nodes
+      if (isHover || n.connections >= 4) {
+        ctx.fillStyle = '#e8eaf6';
+        ctx.font = (isHover ? 'bold ' : '') + '11px Inter, system-ui, sans-serif';
+        ctx.textAlign = 'center';
+        ctx.fillText(n.id, n.x, n.y - r - 6);
+      }
+    }
+    simulate();
+    requestAnimationFrame(draw);
+  }
+  draw();
+
+  // Interaction
+  const tooltip = document.getElementById('graph-tooltip');
+  function getNodeAt(mx, my) {
+    for (let i = nodes.length - 1; i >= 0; i--) {
+      const n = nodes[i], r = getNodeRadius(n);
+      if (Math.hypot(mx - n.x, my - n.y) <= r + 4) return n;
+    }
+    return null;
+  }
+  function getPos(e) {
+    const rect = canvas.getBoundingClientRect();
+    return { x: e.clientX - rect.left, y: e.clientY - rect.top };
+  }
+  canvas.addEventListener('mousemove', function(e) {
+    const p = getPos(e);
+    if (dragging) {
+      dragging.x = p.x + dragOff.x;
+      dragging.y = p.y + dragOff.y;
+      dragging.vx = 0; dragging.vy = 0;
+      return;
+    }
+    const n = getNodeAt(p.x, p.y);
+    hovered = n;
+    canvas.style.cursor = n ? 'pointer' : 'grab';
+    if (n) {
+      const conns = graphEdges.filter(e => e.source === n || e.target === n);
+      tooltip.innerHTML = '<strong>' + n.id + '</strong><br>' + conns.length + ' connections';
+      tooltip.style.display = 'block';
+      tooltip.style.left = (p.x + 15) + 'px';
+      tooltip.style.top = (p.y - 10) + 'px';
+    } else {
+      tooltip.style.display = 'none';
+    }
+  });
+  canvas.addEventListener('mousedown', function(e) {
+    const p = getPos(e);
+    const n = getNodeAt(p.x, p.y);
+    if (n) {
+      dragging = n;
+      dragOff = { x: n.x - p.x, y: n.y - p.y };
+      canvas.style.cursor = 'grabbing';
+    }
+  });
+  canvas.addEventListener('mouseup', function() { dragging = null; });
+  canvas.addEventListener('mouseleave', function() { dragging = null; hovered = null; tooltip.style.display = 'none'; });
+})();
 </script>
 </body>
 </html>`;

package/src/cli/commands/export.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
 
 export function exportCommand(): Command {
   return new Command('export')
@@ -7,6 +8,8 @@ export function exportCommand(): Command {
     .option('--format <fmt>', 'Output format: json (default)', 'json')
     .action(async () => {
       await withIpc(async (client) => {
+        process.stderr.write(`${icons.gear}  ${c.info('Exporting Brain data...')}\n`);
+
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const summary: any = await client.request('analytics.summary', {});
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -22,6 +25,7 @@ export function exportCommand(): Command {
         };
 
         console.log(JSON.stringify(data, null, 2));
+        process.stderr.write(`${icons.ok}  ${c.success('Export complete.')}\n`);
       });
     });
 }

package/src/cli/commands/import.ts

@@ -2,10 +2,13 @@ import { Command } from 'commander';
 import { withIpc } from '../ipc-helper.js';
 import { readdirSync, readFileSync, statSync } from 'fs';
 import { resolve, basename, relative, extname } from 'path';
+import { c, icons, header, divider, progressBar } from '../colors.js';
 
 const DEFAULT_EXTENSIONS = new Set([
   '.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go',
   '.java', '.c', '.cpp', '.h', '.hpp', '.rb', '.sh',
+  '.html', '.css', '.scss', '.json', '.yaml', '.yml', '.toml',
+  '.md', '.sql', '.php', '.svelte', '.vue', '.astro',
 ]);
 
 const EXCLUDE_DIRS = new Set([
@@ -22,6 +25,10 @@ const LANG_MAP: Record<string, string> = {
   py: 'python', rs: 'rust', go: 'go', java: 'java',
   c: 'c', cpp: 'cpp', h: 'c', hpp: 'cpp',
   rb: 'ruby', sh: 'shell', bash: 'shell',
+  html: 'html', css: 'css', scss: 'scss',
+  json: 'json', yaml: 'yaml', yml: 'yaml', toml: 'toml',
+  md: 'markdown', sql: 'sql', php: 'php',
+  svelte: 'svelte', vue: 'vue', astro: 'astro',
 };
 
 function detectLanguage(filePath: string): string {
@@ -75,7 +82,7 @@ export function importCommand(): Command {
     .description('Import source files from a project directory into Brain')
     .argument('<directory>', 'Project directory to scan')
     .option('-p, --project <name>', 'Project name (default: directory basename)')
-    .option('-e, --extensions <list>', 'Comma-separated extensions (default: ts,tsx,js,jsx,py,rs,go,java,c,cpp,h,hpp,rb,sh)')
+    .option('-e, --extensions <list>', 'Comma-separated extensions (default: ts,tsx,js,jsx,py,rs,go,java,c,cpp,h,hpp,rb,sh,html,css,scss,json,yaml,yml,toml,md,sql,php,svelte,vue,astro)')
     .option('--dry-run', 'List files that would be imported without importing')
     .option('--max-size <kb>', 'Skip files larger than N KB', '100')
     .action(async (directory: string, opts) => {
@@ -107,23 +114,23 @@ export function importCommand(): Command {
         process.exit(1);
       }
 
-      console.log(`Scanning ${dir} ...`);
+      console.log(`${icons.search}  ${c.info('Scanning')} ${c.value(dir)} ...`);
       const files = findSourceFiles(dir, extensions, maxSizeBytes);
 
       if (files.length === 0) {
-        console.log('No source files found.');
+        console.log(`${c.dim('No source files found.')}`);
         return;
       }
 
-      console.log(`Found ${files.length} source files.\n`);
+      console.log(`${icons.ok}  Found ${c.value(files.length)} source files.\n`);
 
       if (opts.dryRun) {
         for (const f of files) {
           const rel = relative(dir, f);
           const lang = detectLanguage(f);
-          console.log(`  [${lang}] ${rel}`);
+          console.log(`  ${c.cyan(`[${lang}]`)} ${c.dim(rel)}`);
         }
-        console.log(`\n${files.length} files would be imported as project "${projectName}".`);
+        console.log(`\n${c.value(files.length)} files would be imported as project ${c.cyan(`"${projectName}"`)}.`);
         return;
       }
 
@@ -146,7 +153,7 @@ export function importCommand(): Command {
             source = readFileSync(filePath, 'utf-8');
           } catch {
             failedCount++;
-            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} — read error\n`);
+            process.stdout.write(`  ${c.dim(`[${i + 1}/${files.length}]`)} ${c.dim(rel)} ${c.red('— read error')}\n`);
             continue;
           }
 
@@ -164,27 +171,29 @@ export function importCommand(): Command {
             });
 
             const score = result.reusabilityScore ?? 0;
-            const status = result.isNew ? 'new' : 'existing';
+            const scoreColor = score >= 0.7 ? c.green : score >= 0.4 ? c.orange : c.red;
+            const statusTag = result.isNew ? c.green('new') : c.dim('existing');
             totalScore += score;
             imported++;
 
             if (result.isNew) newCount++;
             else existingCount++;
 
-            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} → score: ${score.toFixed(2)} (${status})\n`);
+            process.stdout.write(`  ${c.dim(`[${i + 1}/${files.length}]`)} ${c.dim(rel)} ${c.dim(icons.arrow)} ${scoreColor(score.toFixed(2))} (${statusTag})\n`);
           } catch (err) {
             failedCount++;
             const msg = err instanceof Error ? err.message : String(err);
-            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} — failed: ${msg.slice(0, 80)}\n`);
+            process.stdout.write(`  ${c.dim(`[${i + 1}/${files.length}]`)} ${c.dim(rel)} ${c.red(`— ${msg.slice(0, 80)}`)}\n`);
           }
         }
 
         const avgScore = imported > 0 ? (totalScore / imported).toFixed(2) : '0';
-        console.log(`\n--- Import Summary ---`);
-        console.log(`  Project:  ${projectName}`);
-        console.log(`  Imported: ${imported} (${newCount} new, ${existingCount} existing)`);
-        if (failedCount > 0) console.log(`  Failed:   ${failedCount}`);
-        console.log(`  Avg reusability score: ${avgScore}`);
+        console.log(header('Import Summary', icons.module));
+        console.log(`  ${c.label('Project:')}  ${c.cyan(projectName)}`);
+        console.log(`  ${c.label('Imported:')} ${c.value(imported)} (${c.green(`${newCount} new`)}, ${c.dim(`${existingCount} existing`)})`);
+        if (failedCount > 0) console.log(`  ${c.label('Failed:')}   ${c.red(failedCount)}`);
+        console.log(`  ${c.label('Avg score:')} ${c.value(avgScore)}  ${progressBar(parseFloat(avgScore), 1)}`);
+        console.log(divider());
       });
     });
 }