design-learn-server 0.1.1

package/src/storage/paths.js

@@ -0,0 +1,113 @@
+const os = require('os');
+const path = require('path');
+
+function expandHome(inputPath) {
+  if (!inputPath || typeof inputPath !== 'string') {
+    return inputPath;
+  }
+
+  if (inputPath === '~') {
+    return os.homedir();
+  }
+
+  if (inputPath.startsWith('~/')) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+
+  return inputPath;
+}
+
+function resolveDataDir(override) {
+  const candidate =
+    override || process.env.DESIGN_LEARN_DATA_DIR || process.env.DATA_DIR;
+  if (candidate) {
+    return expandHome(candidate);
+  }
+
+  return path.join(os.homedir(), '.design-learn', 'data');
+}
+
+function getDesignDir(dataDir, designId) {
+  return path.join(dataDir, 'designs', designId);
+}
+
+function getDesignMetaPath(dataDir, designId) {
+  return path.join(getDesignDir(dataDir, designId), 'design.json');
+}
+
+function getDesignIndexPath(dataDir) {
+  return path.join(dataDir, 'designs', '_index.json');
+}
+
+function getVersionDir(dataDir, designId, versionNumber) {
+  return path.join(getDesignDir(dataDir, designId), `v${versionNumber}`);
+}
+
+function getStyleguidePath(dataDir, designId, versionNumber) {
+  return path.join(getVersionDir(dataDir, designId, versionNumber), 'styleguide.md');
+}
+
+function getRulesPath(dataDir, designId, versionNumber) {
+  return path.join(getVersionDir(dataDir, designId, versionNumber), 'rules.json');
+}
+
+function getSnapshotsPath(dataDir, designId, versionNumber) {
+  return path.join(getVersionDir(dataDir, designId, versionNumber), 'snapshots.json');
+}
+
+function getComponentsDir(dataDir, designId, versionNumber) {
+  return path.join(getVersionDir(dataDir, designId, versionNumber), 'components');
+}
+
+function getComponentDir(dataDir, designId, versionNumber, componentId) {
+  return path.join(getComponentsDir(dataDir, designId, versionNumber), componentId);
+}
+
+function getComponentCodePath(dataDir, designId, versionNumber, componentId) {
+  return path.join(getComponentDir(dataDir, designId, versionNumber, componentId), 'code.json');
+}
+
+function getComponentsIndexPath(dataDir) {
+  return path.join(dataDir, 'components', '_index.json');
+}
+
+function getRulesDir(dataDir, designId, versionNumber) {
+  return path.join(getVersionDir(dataDir, designId, versionNumber), 'rules');
+}
+
+function getRulePath(dataDir, designId, versionNumber, ruleId) {
+  return path.join(getRulesDir(dataDir, designId, versionNumber), `${ruleId}.json`);
+}
+
+function getRulesIndexPath(dataDir) {
+  return path.join(dataDir, 'rules', '_index.json');
+}
+
+function getDatabasePath(dataDir) {
+  return path.join(dataDir, 'database.sqlite');
+}
+
+function getConfigPath(dataDir) {
+  return path.join(dataDir, 'config.json');
+}
+
+module.exports = {
+  expandHome,
+  resolveDataDir,
+  getDesignDir,
+  getDesignMetaPath,
+  getDesignIndexPath,
+  getVersionDir,
+  getStyleguidePath,
+  getRulesPath,
+  getSnapshotsPath,
+  getComponentsDir,
+  getComponentDir,
+  getComponentCodePath,
+  getComponentsIndexPath,
+  getRulesDir,
+  getRulePath,
+  getRulesIndexPath,
+  getDatabasePath,
+  getConfigPath,
+};

package/src/storage/sqliteStore.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const Database = require('better-sqlite3');
+
+const SCHEMA_VERSION = 2;
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function openDatabase(dbPath) {
+  ensureDir(path.dirname(dbPath));
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  migrate(db);
+  return db;
+}
+
+function migrate(db) {
+  const version = db.pragma('user_version', { simple: true });
+  if (version === SCHEMA_VERSION) {
+    return;
+  }
+
+  if (version !== 0 && version !== 1) {
+    throw new Error(`Unsupported schema version ${version}`);
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS designs (
+      id TEXT PRIMARY KEY,
+      name TEXT,
+      url TEXT,
+      source TEXT,
+      category TEXT,
+      description TEXT,
+      thumbnail TEXT,
+      stats_json TEXT,
+      metadata_json TEXT,
+      design_path TEXT,
+      created_at TEXT,
+      updated_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS versions (
+      id TEXT PRIMARY KEY,
+      design_id TEXT NOT NULL,
+      version_number INTEGER NOT NULL,
+      styleguide_path TEXT,
+      rules_path TEXT,
+      snapshots_path TEXT,
+      created_at TEXT,
+      created_by TEXT,
+      FOREIGN KEY (design_id) REFERENCES designs(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS components (
+      id TEXT PRIMARY KEY,
+      design_id TEXT NOT NULL,
+      version_id TEXT NOT NULL,
+      name TEXT,
+      type TEXT,
+      structure_json TEXT,
+      code_path TEXT,
+      preview_path TEXT,
+      created_at TEXT,
+      FOREIGN KEY (design_id) REFERENCES designs(id) ON DELETE CASCADE,
+      FOREIGN KEY (version_id) REFERENCES versions(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS rules (
+      id TEXT PRIMARY KEY,
+      version_id TEXT NOT NULL,
+      type TEXT,
+      name TEXT,
+      value TEXT,
+      raw_path TEXT,
+      created_at TEXT,
+      FOREIGN KEY (version_id) REFERENCES versions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_versions_design_id ON versions(design_id);
+    CREATE INDEX IF NOT EXISTS idx_components_design_id ON components(design_id);
+    CREATE INDEX IF NOT EXISTS idx_components_version_id ON components(version_id);
+    CREATE INDEX IF NOT EXISTS idx_rules_version_id ON rules(version_id);
+    CREATE INDEX IF NOT EXISTS idx_designs_updated_at ON designs(updated_at);
+
+    -- 任务队列表
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      url TEXT NOT NULL,
+      domain TEXT,
+      status TEXT DEFAULT 'pending',
+      progress INTEGER DEFAULT 0,
+      stage TEXT,
+      error TEXT,
+      options_json TEXT,
+      created_at TEXT,
+      updated_at TEXT,
+      completed_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_domain ON tasks(domain);
+    CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+  `);
+
+  db.pragma(`user_version = ${SCHEMA_VERSION}`);
+}
+
+module.exports = {
+  openDatabase,
+  SCHEMA_VERSION,
+};

package/src/uipro/bm25.js

@@ -0,0 +1,121 @@
+const DEFAULT_K1 = 1.5;
+const DEFAULT_B = 0.75;
+
+class BM25 {
+  constructor(options = {}) {
+    this.k1 = Number.isFinite(options.k1) ? options.k1 : DEFAULT_K1;
+    this.b = Number.isFinite(options.b) ? options.b : DEFAULT_B;
+    this.corpus = [];
+    this.termFrequencies = [];
+    this.docLengths = [];
+    this.avgdl = 0;
+    this.idf = new Map();
+    this.N = 0;
+  }
+
+  tokenize(text) {
+    const normalized = String(text ?? '')
+      .toLowerCase()
+      // 保留 Unicode 字母/数字 + 空白，避免中文被直接清空
+      .replace(/[^\p{L}\p{N}\s]+/gu, ' ')
+      .trim();
+
+    if (!normalized) return [];
+
+    const tokens = [];
+    for (const raw of normalized.split(/\s+/)) {
+      if (!raw) continue;
+
+      // CJK 词：拆成 2-gram，提升“按钮/表单”等短词的可用性
+      if (/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(raw)) {
+        if (raw.length === 1) {
+          tokens.push(raw);
+          continue;
+        }
+        for (let i = 0; i < raw.length - 1; i += 1) {
+          tokens.push(raw.slice(i, i + 2));
+        }
+        continue;
+      }
+
+      // 英文/数字：允许 2 字符（如 ui/ux/cta）
+      if (raw.length >= 2) tokens.push(raw);
+    }
+
+    return tokens;
+  }
+
+  fit(documents) {
+    if (!Array.isArray(documents) || documents.length === 0) {
+      this.N = 0;
+      return;
+    }
+
+    this.corpus = documents.map((doc) => this.tokenize(doc));
+    this.N = this.corpus.length;
+    this.docLengths = this.corpus.map((tokens) => tokens.length);
+    this.avgdl = this.docLengths.reduce((sum, len) => sum + len, 0) / this.N;
+
+    const docFreqs = new Map();
+    this.termFrequencies = this.corpus.map((tokens) => {
+      const frequencies = new Map();
+      const seen = new Set();
+      for (const token of tokens) {
+        frequencies.set(token, (frequencies.get(token) || 0) + 1);
+        if (!seen.has(token)) {
+          docFreqs.set(token, (docFreqs.get(token) || 0) + 1);
+          seen.add(token);
+        }
+      }
+      return frequencies;
+    });
+
+    this.idf = new Map();
+    for (const [token, freq] of docFreqs.entries()) {
+      const idf = Math.log((this.N - freq + 0.5) / (freq + 0.5) + 1);
+      this.idf.set(token, idf);
+    }
+  }
+
+  score(query) {
+    if (this.N === 0) {
+      return [];
+    }
+
+    const queryTokens = this.tokenize(query);
+    if (queryTokens.length === 0) {
+      return [];
+    }
+
+    const scored = [];
+    const avgdl = this.avgdl || 1;
+    for (let index = 0; index < this.corpus.length; index += 1) {
+      const docLen = this.docLengths[index] || 0;
+      const frequencies = this.termFrequencies[index];
+      let score = 0;
+
+      for (const token of queryTokens) {
+        const idf = this.idf.get(token);
+        if (idf === undefined) {
+          continue;
+        }
+        const tf = frequencies.get(token) || 0;
+        if (tf === 0) {
+          continue;
+        }
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + (this.b * docLen) / avgdl);
+        score += idf * (numerator / denominator);
+      }
+
+      scored.push([index, score]);
+    }
+
+    scored.sort((a, b) => b[1] - a[1]);
+    return scored;
+  }
+}
+
+module.exports = {
+  BM25,
+};

package/src/uipro/config.js

@@ -0,0 +1,264 @@
+const DOMAIN_CONFIG = {
+  style: {
+    file: 'styles.csv',
+    searchColumns: ['Style Category', 'Keywords', 'Best For', 'Type'],
+    outputColumns: [
+      'Style Category',
+      'Type',
+      'Keywords',
+      'Primary Colors',
+      'Effects & Animation',
+      'Best For',
+      'Performance',
+      'Accessibility',
+      'Framework Compatibility',
+      'Complexity',
+    ],
+  },
+  prompt: {
+    file: 'prompts.csv',
+    searchColumns: ['Style Category', 'AI Prompt Keywords (Copy-Paste Ready)', 'CSS/Technical Keywords'],
+    outputColumns: [
+      'Style Category',
+      'AI Prompt Keywords (Copy-Paste Ready)',
+      'CSS/Technical Keywords',
+      'Implementation Checklist',
+    ],
+  },
+  color: {
+    file: 'colors.csv',
+    searchColumns: ['Product Type', 'Keywords', 'Notes'],
+    outputColumns: [
+      'Product Type',
+      'Keywords',
+      'Primary (Hex)',
+      'Secondary (Hex)',
+      'CTA (Hex)',
+      'Background (Hex)',
+      'Text (Hex)',
+      'Border (Hex)',
+      'Notes',
+    ],
+  },
+  chart: {
+    file: 'charts.csv',
+    searchColumns: ['Data Type', 'Keywords', 'Best Chart Type', 'Accessibility Notes'],
+    outputColumns: [
+      'Data Type',
+      'Keywords',
+      'Best Chart Type',
+      'Secondary Options',
+      'Color Guidance',
+      'Accessibility Notes',
+      'Library Recommendation',
+      'Interactive Level',
+    ],
+  },
+  landing: {
+    file: 'landing.csv',
+    searchColumns: ['Pattern Name', 'Keywords', 'Conversion Optimization', 'Section Order'],
+    outputColumns: [
+      'Pattern Name',
+      'Keywords',
+      'Section Order',
+      'Primary CTA Placement',
+      'Color Strategy',
+      'Conversion Optimization',
+    ],
+  },
+  product: {
+    file: 'products.csv',
+    searchColumns: ['Product Type', 'Keywords', 'Primary Style Recommendation', 'Key Considerations'],
+    outputColumns: [
+      'Product Type',
+      'Keywords',
+      'Primary Style Recommendation',
+      'Secondary Styles',
+      'Landing Page Pattern',
+      'Dashboard Style (if applicable)',
+      'Color Palette Focus',
+    ],
+  },
+  ux: {
+    file: 'ux-guidelines.csv',
+    searchColumns: ['Category', 'Issue', 'Description', 'Platform'],
+    outputColumns: [
+      'Category',
+      'Issue',
+      'Platform',
+      'Description',
+      'Do',
+      "Don't",
+      'Code Example Good',
+      'Code Example Bad',
+      'Severity',
+    ],
+  },
+  typography: {
+    file: 'typography.csv',
+    searchColumns: [
+      'Font Pairing Name',
+      'Category',
+      'Mood/Style Keywords',
+      'Best For',
+      'Heading Font',
+      'Body Font',
+    ],
+    outputColumns: [
+      'Font Pairing Name',
+      'Category',
+      'Heading Font',
+      'Body Font',
+      'Mood/Style Keywords',
+      'Best For',
+      'Google Fonts URL',
+      'CSS Import',
+      'Tailwind Config',
+      'Notes',
+    ],
+  },
+  icons: {
+    file: 'icons.csv',
+    searchColumns: ['Category', 'Icon Name', 'Keywords', 'Best For'],
+    outputColumns: ['Category', 'Icon Name', 'Keywords', 'Library', 'Import Code', 'Usage', 'Best For', 'Style'],
+  },
+};
+
+const STACK_CONFIG = {
+  'html-tailwind': { file: 'stacks/html-tailwind.csv' },
+  react: { file: 'stacks/react.csv' },
+  nextjs: { file: 'stacks/nextjs.csv' },
+  vue: { file: 'stacks/vue.csv' },
+  nuxtjs: { file: 'stacks/nuxtjs.csv' },
+  'nuxt-ui': { file: 'stacks/nuxt-ui.csv' },
+  svelte: { file: 'stacks/svelte.csv' },
+  swiftui: { file: 'stacks/swiftui.csv' },
+  'react-native': { file: 'stacks/react-native.csv' },
+  flutter: { file: 'stacks/flutter.csv' },
+  shadcn: { file: 'stacks/shadcn.csv' },
+};
+
+const STACK_SEARCH_COLUMNS = ['Category', 'Guideline', 'Description', 'Do', "Don't"];
+const STACK_OUTPUT_COLUMNS = [
+  'Category',
+  'Guideline',
+  'Description',
+  'Do',
+  "Don't",
+  'Code Good',
+  'Code Bad',
+  'Severity',
+  'Docs URL',
+];
+
+const DOMAIN_KEYWORDS = {
+  color: ['color', 'palette', 'hex', '#', 'rgb'],
+  chart: [
+    'chart',
+    'graph',
+    'visualization',
+    'trend',
+    'bar',
+    'pie',
+    'scatter',
+    'heatmap',
+    'funnel',
+  ],
+  landing: [
+    'landing',
+    'page',
+    'cta',
+    'conversion',
+    'hero',
+    'testimonial',
+    'pricing',
+    'section',
+  ],
+  product: [
+    'saas',
+    'ecommerce',
+    'e-commerce',
+    'fintech',
+    'healthcare',
+    'gaming',
+    'portfolio',
+    'crypto',
+    'dashboard',
+  ],
+  prompt: ['prompt', 'css', 'implementation', 'variable', 'checklist', 'tailwind'],
+  style: [
+    'style',
+    'design',
+    'ui',
+    'minimalism',
+    'glassmorphism',
+    'neumorphism',
+    'brutalism',
+    'dark mode',
+    'flat',
+    'aurora',
+  ],
+  ux: [
+    'ux',
+    'usability',
+    'accessibility',
+    'wcag',
+    'touch',
+    'scroll',
+    'animation',
+    'keyboard',
+    'navigation',
+    'mobile',
+  ],
+  typography: ['font', 'typography', 'heading', 'serif', 'sans'],
+  icons: [
+    'icon',
+    'icons',
+    'lucide',
+    'heroicons',
+    'symbol',
+    'glyph',
+    'pictogram',
+    'svg icon',
+  ],
+};
+
+function detectDomain(query) {
+  const queryLower = String(query ?? '').toLowerCase();
+  const scores = new Map();
+
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+    let score = 0;
+    for (const keyword of keywords) {
+      if (queryLower.includes(keyword)) {
+        score += 1;
+      }
+    }
+    scores.set(domain, score);
+  }
+
+  let bestDomain = 'style';
+  let bestScore = 0;
+  for (const [domain, score] of scores.entries()) {
+    if (score > bestScore) {
+      bestDomain = domain;
+      bestScore = score;
+    }
+  }
+
+  return bestScore > 0 ? bestDomain : 'style';
+}
+
+const AVAILABLE_DOMAINS = Object.keys(DOMAIN_CONFIG);
+const AVAILABLE_STACKS = Object.keys(STACK_CONFIG);
+
+module.exports = {
+  DOMAIN_CONFIG,
+  STACK_CONFIG,
+  STACK_SEARCH_COLUMNS,
+  STACK_OUTPUT_COLUMNS,
+  detectDomain,
+  AVAILABLE_DOMAINS,
+  AVAILABLE_STACKS,
+};
+

package/src/uipro/csv.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+
+    if (inQuotes) {
+      if (char === '"') {
+        const next = text[index + 1];
+        if (next === '"') {
+          field += '"';
+          index += 1;
+          continue;
+        }
+        inQuotes = false;
+        continue;
+      }
+      field += char;
+      continue;
+    }
+
+    if (char === '"') {
+      inQuotes = true;
+      continue;
+    }
+
+    if (char === ',') {
+      row.push(field);
+      field = '';
+      continue;
+    }
+
+    if (char === '\r') {
+      continue;
+    }
+
+    if (char === '\n') {
+      row.push(field);
+      field = '';
+      rows.push(row);
+      row = [];
+      continue;
+    }
+
+    field += char;
+  }
+
+  row.push(field);
+  rows.push(row);
+
+  return rows.filter((record) => record.some((cell) => String(cell).trim() !== ''));
+}
+
+function parseCsvFile(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const rows = parseCsv(raw);
+  if (rows.length === 0) {
+    return { headers: [], records: [] };
+  }
+
+  const headers = rows[0].map((cell, index) => {
+    const value = String(cell ?? '');
+    const cleaned = index === 0 ? value.replace(/^\uFEFF/, '') : value;
+    return cleaned.trim();
+  });
+
+  const records = rows.slice(1).map((cells) => {
+    const record = {};
+    for (let index = 0; index < headers.length; index += 1) {
+      const key = headers[index];
+      if (!key) {
+        continue;
+      }
+      record[key] = String(cells[index] ?? '').trim();
+    }
+    return record;
+  });
+
+  return { headers, records };
+}
+
+module.exports = {
+  parseCsvFile,
+};
+